PointWrapper
project_real_point_to_unit_point_on_face(CellAccessorWrapper &cell,
const unsigned int face_no,
- PointWrapper & point);
+ PointWrapper &point);
/**
* Get the underlying mapping.
/**
* Constructor.
*/
- TriaAccessorWrapper(void * tria_accessor,
+ TriaAccessorWrapper(void *tria_accessor,
const int structdim,
const int dim,
const int spacedim);
*/
void
generate_subdivided_hyper_rectangle(boost::python::list &repetitions,
- PointWrapper & p1,
- PointWrapper & p2,
+ PointWrapper &p1,
+ PointWrapper &p2,
const bool colorize = false);
/**
*/
void
generate_subdivided_steps_hyper_rectangle(boost::python::list &step_sizes,
- PointWrapper & p1,
- PointWrapper & p2,
+ PointWrapper &p1,
+ PointWrapper &p2,
const bool colorize = false);
/**
void
generate_subdivided_material_hyper_rectangle(
boost::python::list &spacing,
- PointWrapper & p,
+ PointWrapper &p,
boost::python::list &material_id,
const bool colorize = false);
/*! @copydoc GridGenerator::hyper_shell
*/
void
- generate_hyper_shell(PointWrapper & center,
+ generate_hyper_shell(PointWrapper ¢er,
const double inner_radius,
const double outer_radius,
const unsigned n_cells = 0,
*/
void
replicate_triangulation(TriangulationWrapper &tria_in,
- boost::python::list & extents);
+ boost::python::list &extents);
/*! @copydoc GridGenerator::flatten_triangulation
*/
/*! @copydoc GridTools::find_active_cell_around_point
*/
CellAccessorWrapper
- find_active_cell_around_point(PointWrapper & p,
+ find_active_cell_around_point(PointWrapper &p,
MappingQWrapper mapping = MappingQWrapper());
/*! @copydoc GridTools::find_cells_adjacent_to_vertex
/*! @copydoc GridTools::compute_aspect_ratio_of_cells
*/
boost::python::list
- compute_aspect_ratio_of_cells(const MappingQWrapper & mapping,
+ compute_aspect_ratio_of_cells(const MappingQWrapper &mapping,
const QuadratureWrapper &quadrature);
/**
project_real_point_to_unit_point_on_face(void *mapping_ptr,
void *cell_accessor_ptr,
const unsigned int face_no,
- void * point_ptr)
+ void *point_ptr)
{
const MappingQ<dim, spacedim> *mapping =
static_cast<const MappingQ<dim, spacedim> *>(mapping_ptr);
PointWrapper
MappingQWrapper::transform_unit_to_real_cell(CellAccessorWrapper &cell,
- PointWrapper & p)
+ PointWrapper &p)
{
AssertThrow(
dim == p.get_dim(),
PointWrapper
MappingQWrapper::transform_real_to_unit_cell(CellAccessorWrapper &cell,
- PointWrapper & p)
+ PointWrapper &p)
{
AssertThrow(
spacedim == p.get_dim(),
MappingQWrapper::project_real_point_to_unit_point_on_face(
CellAccessorWrapper &cell,
const unsigned int face_no,
- PointWrapper & p)
+ PointWrapper &p)
{
AssertThrow(
spacedim == p.get_dim(),
ExcMessage("Wrong structdim-dim-spacedim combination."));
}
- TriaAccessorWrapper::TriaAccessorWrapper(void * tria_accessor,
+ TriaAccessorWrapper::TriaAccessorWrapper(void *tria_accessor,
const int structdim,
const int dim,
const int spacedim)
void
create_triangulation(const boost::python::list &vertices_list,
const boost::python::list &cells_vertices,
- void * triangulation)
+ void *triangulation)
{
Triangulation<dim, spacedim> *tria =
static_cast<Triangulation<dim, spacedim> *>(triangulation);
generate_hyper_cube(const double left,
const double right,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
Triangulation<dim, spacedim> *tria =
static_cast<Triangulation<dim, spacedim> *>(triangulation);
template <int dim>
void
generate_simplex(std::vector<PointWrapper> &wrapped_points,
- void * triangulation)
+ void *triangulation)
{
// Cast the PointWrapper objects to Point<dim>
std::vector<Point<dim>> points(dim + 1);
generate_subdivided_hyper_cube(const unsigned int repetitions,
const double left,
const double right,
- void * triangulation)
+ void *triangulation)
{
Triangulation<dim, spacedim> *tria =
static_cast<Triangulation<dim, spacedim> *>(triangulation);
generate_hyper_rectangle(PointWrapper &p1,
PointWrapper &p2,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
AssertThrow(
p1.get_dim() == dim,
const double L,
const unsigned int repetitions,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
Triangulation<dim> *tria =
static_cast<Triangulation<dim> *>(triangulation);
void
generate_subdivided_hyper_rectangle(
const std::vector<unsigned int> &repetitions,
- PointWrapper & p1,
- PointWrapper & p2,
+ PointWrapper &p1,
+ PointWrapper &p2,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
AssertThrow(
p1.get_dim() == dim,
void
generate_subdivided_steps_hyper_rectangle(
const std::vector<std::vector<double>> &step_sizes,
- PointWrapper & p1,
- PointWrapper & p2,
+ PointWrapper &p1,
+ PointWrapper &p2,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
AssertThrow(
p1.get_dim() == dim,
void
generate_subdivided_material_hyper_rectangle(
const std::vector<std::vector<double>> &spacing,
- PointWrapper & p,
- const Table<dim, types::material_id> & material_ids,
+ PointWrapper &p,
+ const Table<dim, types::material_id> &material_ids,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
AssertThrow(
p.get_dim() == dim,
void
generate_general_cell(std::vector<PointWrapper> &wrapped_points,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
// Cast the PointWrapper objects to Point<dim>
const unsigned int size = wrapped_points.size();
void
generate_parallelogram(std::vector<PointWrapper> &wrapped_points,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
// Cast the PointWrapper objects to Point<dim>
Point<dim> points[dim];
void
generate_parallelepiped(std::vector<PointWrapper> &wrapped_points,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
// Cast the PointWrapper objects to Point<dim>
Point<dim> points[dim];
unsigned int n_subdivisions,
std::vector<PointWrapper> &wrapped_points,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
// Cast the PointWrapper objects to Point<dim>
Point<dim> points[dim];
std::vector<unsigned int> &n_subdivisions,
std::vector<PointWrapper> &wrapped_points,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
// Cast the PointWrapper objects to Point<dim>
Point<dim> points[dim];
const double right,
const double thickness,
const bool colorize,
- void * triangulation)
+ void *triangulation)
{
Triangulation<dim> *tria =
static_cast<Triangulation<dim> *>(triangulation);
void
generate_hyper_ball(PointWrapper ¢er,
const double radius,
- void * triangulation)
+ void *triangulation)
{
// Cast the PointWrapper object to Point<dim>
Point<dim> center_point =
void
generate_hyper_sphere(PointWrapper ¢er,
const double radius,
- void * triangulation)
+ void *triangulation)
{
// Cast the PointWrapper object to Point<dim>
Point<spacedim> center_point =
template <int dim>
void
- generate_hyper_shell(PointWrapper & center,
+ generate_hyper_shell(PointWrapper ¢er,
const double inner_radius,
const double outer_radius,
const unsigned n_cells,
bool colorize,
- void * triangulation)
+ void *triangulation)
{
// Cast the PointWrapper object to Point<dim>
Point<dim> center_point =
void
generate_quarter_hyper_ball(PointWrapper ¢er,
const double radius,
- void * triangulation)
+ void *triangulation)
{
// Cast the PointWrapper object to Point<dim>
Point<dim> center_point =
void
generate_half_hyper_ball(PointWrapper ¢er,
const double radius,
- void * triangulation)
+ void *triangulation)
{
// Cast the PointWrapper object to Point<dim>
Point<dim> center_point =
template <int dim, int spacedim>
void
merge_triangulations(boost::python::list &triangulations,
- void * triangulation,
+ void *triangulation,
const double duplicated_vertex_tolerance,
const bool copy_manifold_ids)
{
template <int dim, int spacedim>
void
- convert_hypercube_to_simplex_mesh(void * triangulation,
+ convert_hypercube_to_simplex_mesh(void *triangulation,
TriangulationWrapper &tria_out)
{
Triangulation<dim, spacedim> *tria =
template <int dim, int spacedim>
void
- replicate_triangulation(TriangulationWrapper & tria_in,
+ replicate_triangulation(TriangulationWrapper &tria_in,
const boost::python::list &extents,
- void * tria_out)
+ void *tria_out)
{
Triangulation<dim, spacedim> *replicated_triangulation =
static_cast<Triangulation<dim, spacedim> *>(tria_out);
void
distort_random(const double factor,
const bool keep_boundary,
- void * triangulation)
+ void *triangulation)
{
Triangulation<dim, spacedim> *tria =
static_cast<Triangulation<dim, spacedim> *>(triangulation);
template <int dim, int spacedim>
std::pair<int, int>
- find_active_cell_around_point(PointWrapper & p,
+ find_active_cell_around_point(PointWrapper &p,
MappingQWrapper &mapping_wrapper,
- void * triangulation)
+ void *triangulation)
{
Triangulation<dim, spacedim> *tria =
static_cast<Triangulation<dim, spacedim> *>(triangulation);
template <int dim, int spacedim>
boost::python::list
compute_aspect_ratio_of_cells(
- const MappingQWrapper & mapping_wrapper,
- const QuadratureWrapper & quadrature_wrapper,
+ const MappingQWrapper &mapping_wrapper,
+ const QuadratureWrapper &quadrature_wrapper,
const TriangulationWrapper &triangulation_wrapper)
{
const Triangulation<dim, spacedim> *tria =
void
write(const std::string &filename,
const std::string &format,
- const void * triangulation)
+ const void *triangulation)
{
const Triangulation<dim, spacedim> *tria =
static_cast<const Triangulation<dim, spacedim> *>(triangulation);
void
read(const std::string &filename,
const std::string &format,
- void * triangulation)
+ void *triangulation)
{
Triangulation<dim, spacedim> *tria =
static_cast<Triangulation<dim, spacedim> *>(triangulation);
void
TriangulationWrapper::generate_subdivided_hyper_rectangle(
boost::python::list &repetition_list,
- PointWrapper & p1,
- PointWrapper & p2,
+ PointWrapper &p1,
+ PointWrapper &p2,
const bool colorize)
{
AssertThrow(
void
TriangulationWrapper::generate_subdivided_steps_hyper_rectangle(
boost::python::list &step_sizes_list,
- PointWrapper & p1,
- PointWrapper & p2,
+ PointWrapper &p1,
+ PointWrapper &p2,
const bool colorize)
{
AssertThrow(
void
TriangulationWrapper::generate_subdivided_material_hyper_rectangle(
boost::python::list &spacing_list,
- PointWrapper & p,
+ PointWrapper &p,
boost::python::list &material_id_list,
const bool colorize)
{
void
- TriangulationWrapper::generate_hyper_shell(PointWrapper & center,
+ TriangulationWrapper::generate_hyper_shell(PointWrapper ¢er,
const double inner_radius,
const double outer_radius,
const unsigned n_cells,
void
TriangulationWrapper::replicate_triangulation(
TriangulationWrapper &triangulation_in,
- boost::python::list & extents)
+ boost::python::list &extents)
{
AssertThrow(
boost::python::len(extents) == dim,
CellAccessorWrapper
- TriangulationWrapper::find_active_cell_around_point(PointWrapper & p,
+ TriangulationWrapper::find_active_cell_around_point(PointWrapper &p,
MappingQWrapper mapping)
{
std::pair<int, int> level_index_pair;
boost::python::list
TriangulationWrapper::compute_aspect_ratio_of_cells(
- const MappingQWrapper & mapping,
+ const MappingQWrapper &mapping,
const QuadratureWrapper &quadrature)
{
if ((dim == 2) && (spacedim == 2))
public:
BoundaryValues() = default;
virtual void value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
// scheme.
template <int dim>
void BoundaryValues<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
(void)component;
template <int dim>
struct ScratchData
{
- ScratchData(const Mapping<dim> & mapping,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ ScratchData(const Mapping<dim> &mapping,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &quadrature_face,
const UpdateFlags update_flags = update_values |
update_gradients |
const BoundaryValues<dim> boundary_function;
// This is the function that will be executed for each cell.
- const auto cell_worker = [&](const Iterator & cell,
+ const auto cell_worker = [&](const Iterator &cell,
ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
const unsigned int n_dofs =
scratch_data.fe_values.get_fe().n_dofs_per_cell();
copy_data.reinit(cell, n_dofs);
const auto &q_points = scratch_data.fe_values.get_quadrature_points();
- const FEValues<dim> & fe_v = scratch_data.fe_values;
+ const FEValues<dim> &fe_v = scratch_data.fe_values;
const std::vector<double> &JxW = fe_v.get_JxW_values();
// We solve a homogeneous equation, thus no right hand side shows up in
// This is the function called for boundary faces and consists of a normal
// integration using FEFaceValues. New is the logic to decide if the term
// goes into the system matrix (outflow) or the right-hand side (inflow).
- const auto boundary_worker = [&](const Iterator & cell,
+ const auto boundary_worker = [&](const Iterator &cell,
const unsigned int &face_no,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
scratch_data.fe_interface_values.reinit(cell, face_no);
const FEFaceValuesBase<dim> &fe_face =
scratch_data.fe_interface_values.get_fe_face_values(0);
const auto &q_points = fe_face.get_quadrature_points();
const unsigned int n_facet_dofs = fe_face.get_fe().n_dofs_per_cell();
- const std::vector<double> & JxW = fe_face.get_JxW_values();
+ const std::vector<double> &JxW = fe_face.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_face.get_normal_vectors();
std::vector<double> g(q_points.size());
// This is the function called on interior faces. The arguments specify
// cells, face and subface indices (for adaptive refinement). We just pass
// them along to the reinit() function of FEInterfaceValues.
- const auto face_worker = [&](const Iterator & cell,
+ const auto face_worker = [&](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
FEInterfaceValues<dim> &fe_iv = scratch_data.fe_interface_values;
fe_iv.reinit(cell, f, sf, ncell, nf, nsf);
const auto &q_points = fe_iv.get_quadrature_points();
copy_data_face.cell_matrix.reinit(n_dofs, n_dofs);
- const std::vector<double> & JxW = fe_iv.get_JxW_values();
+ const std::vector<double> &JxW = fe_iv.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_iv.get_normal_vectors();
for (unsigned int qpoint = 0; qpoint < q_points.size(); ++qpoint)
public:
BoundaryValues() = default;
virtual void value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
// scheme.
template <int dim>
void BoundaryValues<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
(void)component;
// bound.
static void integrate_cell_term(DoFInfo &dinfo, CellInfo &info);
static void integrate_boundary_term(DoFInfo &dinfo, CellInfo &info);
- static void integrate_face_term(DoFInfo & dinfo1,
- DoFInfo & dinfo2,
+ static void integrate_face_term(DoFInfo &dinfo1,
+ DoFInfo &dinfo2,
CellInfo &info1,
CellInfo &info2);
};
// just above. They compute the local contributions to the system matrix and
// right hand side on cells and faces.
template <int dim>
- void AdvectionProblem<dim>::integrate_cell_term(DoFInfo & dinfo,
+ void AdvectionProblem<dim>::integrate_cell_term(DoFInfo &dinfo,
CellInfo &info)
{
// First, let us retrieve some of the objects used here from @p info. Note
// that these objects can handle much more complex structures, thus the
// access here looks more complicated than might seem necessary.
- const FEValuesBase<dim> & fe_values = info.fe_values();
- FullMatrix<double> & local_matrix = dinfo.matrix(0).matrix;
+ const FEValuesBase<dim> &fe_values = info.fe_values();
+ FullMatrix<double> &local_matrix = dinfo.matrix(0).matrix;
const std::vector<double> &JxW = fe_values.get_JxW_values();
// With these objects, we continue local integration like always. First, we
// base class for both FEFaceValues and FESubfaceValues, in order to get
// access to normal vectors.
template <int dim>
- void AdvectionProblem<dim>::integrate_boundary_term(DoFInfo & dinfo,
+ void AdvectionProblem<dim>::integrate_boundary_term(DoFInfo &dinfo,
CellInfo &info)
{
const FEValuesBase<dim> &fe_face_values = info.fe_values();
- FullMatrix<double> & local_matrix = dinfo.matrix(0).matrix;
- Vector<double> & local_vector = dinfo.vector(0).block(0);
+ FullMatrix<double> &local_matrix = dinfo.matrix(0).matrix;
+ Vector<double> &local_vector = dinfo.vector(0).block(0);
- const std::vector<double> & JxW = fe_face_values.get_JxW_values();
+ const std::vector<double> &JxW = fe_face_values.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals =
fe_face_values.get_normal_vectors();
// two info objects, one for each cell adjacent to the face and we assemble
// four matrices, one for each cell and two for coupling back and forth.
template <int dim>
- void AdvectionProblem<dim>::integrate_face_term(DoFInfo & dinfo1,
- DoFInfo & dinfo2,
+ void AdvectionProblem<dim>::integrate_face_term(DoFInfo &dinfo1,
+ DoFInfo &dinfo2,
CellInfo &info1,
CellInfo &info2)
{
// hand side vectors. Fortunately, the interface terms only involve the
// solution and the right hand side does not receive any contributions.
- const std::vector<double> & JxW = fe_face_values.get_JxW_values();
+ const std::vector<double> &JxW = fe_face_values.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals =
fe_face_values.get_normal_vectors();
void set_refinement_cycle(const unsigned int refinement_cycle);
virtual void operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const = 0;
+ const Vector<double> &solution) const = 0;
protected:
unsigned int refinement_cycle;
{
public:
PointValueEvaluation(const Point<dim> &evaluation_point,
- TableHandler & results_table);
+ TableHandler &results_table);
virtual void operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const override;
+ const Vector<double> &solution) const override;
DeclException1(
ExcEvaluationPointNotFound,
private:
const Point<dim> evaluation_point;
- TableHandler & results_table;
+ TableHandler &results_table;
};
template <int dim>
PointValueEvaluation<dim>::PointValueEvaluation(
const Point<dim> &evaluation_point,
- TableHandler & results_table)
+ TableHandler &results_table)
: evaluation_point(evaluation_point)
, results_table(results_table)
{}
template <int dim>
void
PointValueEvaluation<dim>::operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ const Vector<double> &solution) const
{
// First allocate a variable that will hold the point value. Initialize
// it with a value that is clearly bogus, so that if we fail to set it
class SolutionOutput : public EvaluationBase<dim>
{
public:
- SolutionOutput(const std::string & output_name_base,
+ SolutionOutput(const std::string &output_name_base,
const DataOutBase::OutputFormat output_format);
virtual void operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const override;
+ const Vector<double> &solution) const override;
private:
const std::string output_name_base;
template <int dim>
SolutionOutput<dim>::SolutionOutput(
- const std::string & output_name_base,
+ const std::string &output_name_base,
const DataOutBase::OutputFormat output_format)
: output_name_base(output_name_base)
, output_format(output_format)
// there).
template <int dim>
void SolutionOutput<dim>::operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ const Vector<double> &solution) const
{
DataOut<dim> data_out;
data_out.attach_dof_handler(dof_handler);
class Solver : public virtual Base<dim>
{
public:
- Solver(Triangulation<dim> & triangulation,
+ Solver(Triangulation<dim> &triangulation,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & boundary_values);
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &boundary_values);
virtual ~Solver() override;
virtual void solve_problem() override;
struct AssemblyScratchData
{
AssemblyScratchData(const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature);
+ const Quadrature<dim> &quadrature);
AssemblyScratchData(const AssemblyScratchData &scratch_data);
FEValues<dim> fe_values;
void local_assemble_matrix(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- AssemblyScratchData & scratch_data,
- AssemblyCopyData & copy_data) const;
+ AssemblyScratchData &scratch_data,
+ AssemblyCopyData ©_data) const;
void copy_local_to_global(const AssemblyCopyData ©_data,
- LinearSystem & linear_system) const;
+ LinearSystem &linear_system) const;
};
// does not already generate a finite element numbering (we only ask for
// that in the <code>solve_problem</code> function).
template <int dim>
- Solver<dim>::Solver(Triangulation<dim> & triangulation,
+ Solver<dim>::Solver(Triangulation<dim> &triangulation,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & boundary_values)
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &boundary_values)
: Base<dim>(triangulation)
, fe(&fe)
, quadrature(&quadrature)
auto worker =
[this](const typename DoFHandler<dim>::active_cell_iterator &cell,
AssemblyScratchData &scratch_data,
- AssemblyCopyData & copy_data) {
+ AssemblyCopyData ©_data) {
this->local_assemble_matrix(cell, scratch_data, copy_data);
};
template <int dim>
Solver<dim>::AssemblyScratchData::AssemblyScratchData(
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature)
+ const Quadrature<dim> &quadrature)
: fe_values(fe, quadrature, update_gradients | update_JxW_values)
{}
template <int dim>
void Solver<dim>::local_assemble_matrix(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- AssemblyScratchData & scratch_data,
- AssemblyCopyData & copy_data) const
+ AssemblyScratchData &scratch_data,
+ AssemblyCopyData ©_data) const
{
const unsigned int dofs_per_cell = fe->n_dofs_per_cell();
const unsigned int n_q_points = quadrature->size();
class PrimalSolver : public Solver<dim>
{
public:
- PrimalSolver(Triangulation<dim> & triangulation,
+ PrimalSolver(Triangulation<dim> &triangulation,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
protected:
const SmartPointer<const Function<dim>> rhs_function;
// The constructor of this class basically does what it is announced to do
// above...
template <int dim>
- PrimalSolver<dim>::PrimalSolver(Triangulation<dim> & triangulation,
+ PrimalSolver<dim>::PrimalSolver(Triangulation<dim> &triangulation,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values)
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values)
: Base<dim>(triangulation)
, Solver<dim>(triangulation, fe, quadrature, boundary_values)
, rhs_function(&rhs_function)
class RefinementGlobal : public PrimalSolver<dim>
{
public:
- RefinementGlobal(Triangulation<dim> & coarse_grid,
+ RefinementGlobal(Triangulation<dim> &coarse_grid,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void refine_grid() override;
};
template <int dim>
RefinementGlobal<dim>::RefinementGlobal(
- Triangulation<dim> & coarse_grid,
+ Triangulation<dim> &coarse_grid,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values)
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values)
: Base<dim>(coarse_grid)
, PrimalSolver<dim>(coarse_grid,
fe,
class RefinementKelly : public PrimalSolver<dim>
{
public:
- RefinementKelly(Triangulation<dim> & coarse_grid,
+ RefinementKelly(Triangulation<dim> &coarse_grid,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void refine_grid() override;
};
template <int dim>
- RefinementKelly<dim>::RefinementKelly(Triangulation<dim> & coarse_grid,
+ RefinementKelly<dim>::RefinementKelly(Triangulation<dim> &coarse_grid,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const Function<dim> &rhs_function,
const Function<dim> &boundary_values)
: Base<dim>(coarse_grid)
class Solution : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component) const override;
};
template <int dim>
- double Solution<dim>::value(const Point<dim> & p,
+ double Solution<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
class RightHandSide : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component) const override;
};
template <int dim>
- double RightHandSide<dim>::value(const Point<dim> & p,
+ double RightHandSide<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
// intermittent mesh refinement:
template <int dim>
void run_simulation(
- LaplaceSolver::Base<dim> & solver,
+ LaplaceSolver::Base<dim> &solver,
const std::list<Evaluation::EvaluationBase<dim> *> &postprocessor_list)
{
// We will give an indicator of the step we are presently computing, in
void set_refinement_cycle(const unsigned int refinement_cycle);
virtual void operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const = 0;
+ const Vector<double> &solution) const = 0;
protected:
unsigned int refinement_cycle;
PointValueEvaluation(const Point<dim> &evaluation_point);
virtual void operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const override;
+ const Vector<double> &solution) const override;
DeclException1(
ExcEvaluationPointNotFound,
template <int dim>
void
PointValueEvaluation<dim>::operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ const Vector<double> &solution) const
{
double point_value = 1e20;
PointXDerivativeEvaluation(const Point<dim> &evaluation_point);
virtual void operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const;
+ const Vector<double> &solution) const;
DeclException1(
ExcEvaluationPointNotFound,
template <int dim>
void PointXDerivativeEvaluation<dim>::operator()(
const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ const Vector<double> &solution) const
{
// This time initialize the return value with something useful, since we
// will have to add up a number of contributions and take the mean value
GridOutput(const std::string &output_name_base);
virtual void operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const override;
+ const Vector<double> &solution) const override;
private:
const std::string output_name_base;
class Solver : public virtual Base<dim>
{
public:
- Solver(Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ Solver(Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & boundary_values);
+ const Function<dim> &boundary_values);
virtual ~Solver() override;
virtual void solve_problem() override;
struct AssemblyScratchData
{
AssemblyScratchData(const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature);
+ const Quadrature<dim> &quadrature);
AssemblyScratchData(const AssemblyScratchData &scratch_data);
FEValues<dim> fe_values;
void local_assemble_matrix(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- AssemblyScratchData & scratch_data,
- AssemblyCopyData & copy_data) const;
+ AssemblyScratchData &scratch_data,
+ AssemblyCopyData ©_data) const;
void copy_local_to_global(const AssemblyCopyData ©_data,
- LinearSystem & linear_system) const;
+ LinearSystem &linear_system) const;
};
template <int dim>
- Solver<dim>::Solver(Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ Solver<dim>::Solver(Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & boundary_values)
+ const Function<dim> &boundary_values)
: Base<dim>(triangulation)
, fe(&fe)
, quadrature(&quadrature)
auto worker =
[this](const typename DoFHandler<dim>::active_cell_iterator &cell,
AssemblyScratchData &scratch_data,
- AssemblyCopyData & copy_data) {
+ AssemblyCopyData ©_data) {
this->local_assemble_matrix(cell, scratch_data, copy_data);
};
template <int dim>
Solver<dim>::AssemblyScratchData::AssemblyScratchData(
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature)
+ const Quadrature<dim> &quadrature)
: fe_values(fe, quadrature, update_gradients | update_JxW_values)
{}
template <int dim>
void Solver<dim>::local_assemble_matrix(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- AssemblyScratchData & scratch_data,
- AssemblyCopyData & copy_data) const
+ AssemblyScratchData &scratch_data,
+ AssemblyCopyData ©_data) const
{
const unsigned int dofs_per_cell = fe->n_dofs_per_cell();
const unsigned int n_q_points = quadrature->size();
class PrimalSolver : public Solver<dim>
{
public:
- PrimalSolver(Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ PrimalSolver(Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void output_solution() const override;
template <int dim>
- PrimalSolver<dim>::PrimalSolver(Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ PrimalSolver<dim>::PrimalSolver(Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values)
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values)
: Base<dim>(triangulation)
, Solver<dim>(triangulation,
fe,
class RefinementGlobal : public PrimalSolver<dim>
{
public:
- RefinementGlobal(Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ RefinementGlobal(Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void refine_grid() override;
};
template <int dim>
RefinementGlobal<dim>::RefinementGlobal(
- Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values)
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values)
: Base<dim>(coarse_grid)
, PrimalSolver<dim>(coarse_grid,
fe,
class RefinementKelly : public PrimalSolver<dim>
{
public:
- RefinementKelly(Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ RefinementKelly(Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void refine_grid() override;
};
template <int dim>
RefinementKelly<dim>::RefinementKelly(
- Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values)
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values)
: Base<dim>(coarse_grid)
, PrimalSolver<dim>(coarse_grid,
fe,
class RefinementWeightedKelly : public PrimalSolver<dim>
{
public:
- RefinementWeightedKelly(Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ RefinementWeightedKelly(Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values,
- const Function<dim> & weighting_function);
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values,
+ const Function<dim> &weighting_function);
virtual void refine_grid() override;
template <int dim>
RefinementWeightedKelly<dim>::RefinementWeightedKelly(
- Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values,
- const Function<dim> & weighting_function)
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values,
+ const Function<dim> &weighting_function)
: Base<dim>(coarse_grid)
, PrimalSolver<dim>(coarse_grid,
fe,
class BoundaryValues : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component) const;
};
class RightHandSide : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component) const;
};
{
public:
virtual void assemble_rhs(const DoFHandler<dim> &dof_handler,
- Vector<double> & rhs) const = 0;
+ Vector<double> &rhs) const = 0;
};
PointValueEvaluation(const Point<dim> &evaluation_point);
virtual void assemble_rhs(const DoFHandler<dim> &dof_handler,
- Vector<double> & rhs) const override;
+ Vector<double> &rhs) const override;
DeclException1(
ExcEvaluationPointNotFound,
template <int dim>
void
PointValueEvaluation<dim>::assemble_rhs(const DoFHandler<dim> &dof_handler,
- Vector<double> & rhs) const
+ Vector<double> &rhs) const
{
// So, first set everything to zeros...
rhs.reinit(dof_handler.n_dofs());
PointXDerivativeEvaluation(const Point<dim> &evaluation_point);
virtual void assemble_rhs(const DoFHandler<dim> &dof_handler,
- Vector<double> & rhs) const;
+ Vector<double> &rhs) const;
DeclException1(
ExcEvaluationPointNotFound,
template <int dim>
void PointXDerivativeEvaluation<dim>::assemble_rhs(
const DoFHandler<dim> &dof_handler,
- Vector<double> & rhs) const
+ Vector<double> &rhs) const
{
// Again, first set all entries to zero:
rhs.reinit(dof_handler.n_dofs());
{
public:
DualSolver(
- Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
- const Quadrature<dim - 1> & face_quadrature,
+ Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
+ const Quadrature<dim - 1> &face_quadrature,
const DualFunctional::DualFunctionalBase<dim> &dual_functional);
protected:
template <int dim>
DualSolver<dim>::DualSolver(
- Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
- const Quadrature<dim - 1> & face_quadrature,
+ Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
+ const Quadrature<dim - 1> &face_quadrature,
const DualFunctional::DualFunctionalBase<dim> &dual_functional)
: Base<dim>(triangulation)
, Solver<dim>(triangulation,
{
public:
WeightedResidual(
- Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & primal_fe,
- const FiniteElement<dim> & dual_fe,
- const Quadrature<dim> & quadrature,
- const Quadrature<dim - 1> & face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values,
+ Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &primal_fe,
+ const FiniteElement<dim> &dual_fe,
+ const Quadrature<dim> &quadrature,
+ const Quadrature<dim - 1> &face_quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values,
const DualFunctional::DualFunctionalBase<dim> &dual_functional);
virtual void solve_problem() override;
std::vector<double> dual_weights;
std::vector<double> cell_laplacians;
CellData(const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & right_hand_side);
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &right_hand_side);
CellData(const CellData &cell_data);
};
std::vector<double> dual_weights;
typename std::vector<Tensor<1, dim>> cell_grads;
typename std::vector<Tensor<1, dim>> neighbor_grads;
- FaceData(const FiniteElement<dim> & fe,
+ FaceData(const FiniteElement<dim> &fe,
const Quadrature<dim - 1> &face_quadrature);
FaceData(const FaceData &face_data);
};
struct WeightedResidualScratchData
{
WeightedResidualScratchData(
- const FiniteElement<dim> & primal_fe,
- const Quadrature<dim> & primal_quadrature,
+ const FiniteElement<dim> &primal_fe,
+ const Quadrature<dim> &primal_quadrature,
const Quadrature<dim - 1> &primal_face_quadrature,
- const Function<dim> & rhs_function,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights);
+ const Function<dim> &rhs_function,
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights);
WeightedResidualScratchData(
const WeightedResidualScratchData &scratch_data);
// every cell:
void estimate_error(Vector<float> &error_indicators) const;
- void estimate_on_one_cell(const active_cell_iterator & cell,
+ void estimate_on_one_cell(const active_cell_iterator &cell,
WeightedResidualScratchData &scratch_data,
- WeightedResidualCopyData & copy_data,
- Vector<float> & error_indicators,
+ WeightedResidualCopyData ©_data,
+ Vector<float> &error_indicators,
FaceIntegrals &face_integrals) const;
// Then we have functions that do the actual integration of the error
// interiors, on those faces that have no hanging nodes, and on those
// faces with hanging nodes, respectively:
void integrate_over_cell(const active_cell_iterator &cell,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights,
- CellData & cell_data,
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights,
+ CellData &cell_data,
Vector<float> &error_indicators) const;
void integrate_over_regular_face(const active_cell_iterator &cell,
const unsigned int face_no,
const Vector<double> &primal_solution,
const Vector<double> &dual_weights,
- FaceData & face_data,
+ FaceData &face_data,
FaceIntegrals &face_integrals) const;
void integrate_over_irregular_face(const active_cell_iterator &cell,
const unsigned int face_no,
const Vector<double> &primal_solution,
const Vector<double> &dual_weights,
- FaceData & face_data,
+ FaceData &face_data,
FaceIntegrals &face_integrals) const;
};
template <int dim>
WeightedResidual<dim>::CellData::CellData(
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & right_hand_side)
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &right_hand_side)
: fe_values(fe,
quadrature,
update_values | update_hessians | update_quadrature_points |
template <int dim>
WeightedResidual<dim>::FaceData::FaceData(
- const FiniteElement<dim> & fe,
+ const FiniteElement<dim> &fe,
const Quadrature<dim - 1> &face_quadrature)
: fe_face_values_cell(fe,
face_quadrature,
template <int dim>
WeightedResidual<dim>::WeightedResidualScratchData::
WeightedResidualScratchData(
- const FiniteElement<dim> & primal_fe,
- const Quadrature<dim> & primal_quadrature,
+ const FiniteElement<dim> &primal_fe,
+ const Quadrature<dim> &primal_quadrature,
const Quadrature<dim - 1> &primal_face_quadrature,
- const Function<dim> & rhs_function,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights)
+ const Function<dim> &rhs_function,
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights)
: cell_data(primal_fe, primal_quadrature, rhs_function)
, face_data(primal_fe, primal_face_quadrature)
, primal_solution(primal_solution)
template <int dim>
WeightedResidual<dim>::WeightedResidual(
- Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & primal_fe,
- const FiniteElement<dim> & dual_fe,
- const Quadrature<dim> & quadrature,
- const Quadrature<dim - 1> & face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & bv,
+ Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &primal_fe,
+ const FiniteElement<dim> &dual_fe,
+ const Quadrature<dim> &quadrature,
+ const Quadrature<dim - 1> &face_quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &bv,
const DualFunctional::DualFunctionalBase<dim> &dual_functional)
: Base<dim>(coarse_grid)
, PrimalSolver<dim>(coarse_grid,
auto worker = [this,
&error_indicators,
- &face_integrals](const active_cell_iterator & cell,
+ &face_integrals](const active_cell_iterator &cell,
WeightedResidualScratchData &scratch_data,
- WeightedResidualCopyData & copy_data) {
+ WeightedResidualCopyData ©_data) {
this->estimate_on_one_cell(
cell, scratch_data, copy_data, error_indicators, face_integrals);
};
// configured to use multithreading. Here it goes:
template <int dim>
void WeightedResidual<dim>::estimate_on_one_cell(
- const active_cell_iterator & cell,
+ const active_cell_iterator &cell,
WeightedResidualScratchData &scratch_data,
- WeightedResidualCopyData & copy_data,
- Vector<float> & error_indicators,
- FaceIntegrals & face_integrals) const
+ WeightedResidualCopyData ©_data,
+ Vector<float> &error_indicators,
+ FaceIntegrals &face_integrals) const
{
// Because of WorkStream, estimate_on_one_cell requires a CopyData object
// even if it is no used. The next line silences a warning about this
template <int dim>
void WeightedResidual<dim>::integrate_over_cell(
const active_cell_iterator &cell,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights,
- CellData & cell_data,
- Vector<float> & error_indicators) const
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights,
+ CellData &cell_data,
+ Vector<float> &error_indicators) const
{
// The tasks to be done are what appears natural from looking at the
// error estimation formula: first get the right hand side and Laplacian
void WeightedResidual<dim>::integrate_over_regular_face(
const active_cell_iterator &cell,
const unsigned int face_no,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights,
- FaceData & face_data,
- FaceIntegrals & face_integrals) const
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights,
+ FaceData &face_data,
+ FaceIntegrals &face_integrals) const
{
const unsigned int n_q_points =
face_data.fe_face_values_cell.n_quadrature_points;
void WeightedResidual<dim>::integrate_over_irregular_face(
const active_cell_iterator &cell,
const unsigned int face_no,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights,
- FaceData & face_data,
- FaceIntegrals & face_integrals) const
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights,
+ FaceData &face_data,
+ FaceIntegrals &face_integrals) const
{
// First again two abbreviations, and some consistency checks whether
// the function is called only on faces for which it is supposed to be
class BoundaryValues : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
template <int dim>
struct ScratchData
{
- ScratchData(const Mapping<dim> & mapping,
+ ScratchData(const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
const unsigned int quadrature_degree,
const UpdateFlags update_flags)
private:
template <class Iterator>
- void cell_worker(const Iterator & cell,
+ void cell_worker(const Iterator &cell,
ScratchData<dim> &scratch_data,
- CopyData & copy_data);
+ CopyData ©_data);
void setup_system();
void assemble_system();
// assemble_multigrid() even though it is not used.
template <int dim>
template <class Iterator>
- void LaplaceProblem<dim>::cell_worker(const Iterator & cell,
+ void LaplaceProblem<dim>::cell_worker(const Iterator &cell,
ScratchData<dim> &scratch_data,
- CopyData & copy_data)
+ CopyData ©_data)
{
FEValues<dim> &fe_values = scratch_data.fe_values;
fe_values.reinit(cell);
auto cell_worker =
[&](const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
this->cell_worker(cell, scratch_data, copy_data);
};
auto cell_worker =
[&](const typename DoFHandler<dim>::level_cell_iterator &cell,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
this->cell_worker(cell, scratch_data, copy_data);
};
{
public:
LaplaceIntegrator();
- virtual void cell(MeshWorker::DoFInfo<dim> & dinfo,
+ virtual void cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info) const override;
};
// information into block zero of vector zero.
template <int dim>
void
- LaplaceIntegrator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+ LaplaceIntegrator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info) const
{
AssertDimension(dinfo.n_matrices(), 1);
{
public:
virtual void vector_value(const Point<dim> &p,
- Vector<double> & values) const override
+ Vector<double> &values) const override
{
AssertDimension(values.size(), dim);
Assert(dim >= 2, ExcInternalError());
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const override
+ std::vector<Vector<double>> &value_list) const override
{
const unsigned int n_points = points.size();
BodyForce();
virtual void vector_value(const Point<dim> &p,
- Vector<double> & values) const override;
+ Vector<double> &values) const override;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const override;
+ std::vector<Vector<double>> &value_list) const override;
};
template <int dim>
void BodyForce<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
const unsigned int n_points = points.size();
const double present_timestep);
virtual void vector_value(const Point<dim> &p,
- Vector<double> & values) const override;
+ Vector<double> &values) const override;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const override;
+ std::vector<Vector<double>> &value_list) const override;
private:
const double velocity;
template <int dim>
void IncrementalBoundaryValues<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
const unsigned int n_points = points.size();
void create_particles();
void move_particles();
void track_lost_particle(
- const typename Particles::ParticleIterator<dim> & particle,
+ const typename Particles::ParticleIterator<dim> &particle,
const typename Triangulation<dim>::active_cell_iterator &cell);
, time(0, 1e-4)
{
particle_handler.signals.particle_lost.connect(
- [this](const typename Particles::ParticleIterator<dim> & particle,
+ [this](const typename Particles::ParticleIterator<dim> &particle,
const typename Triangulation<dim>::active_cell_iterator &cell) {
this->track_lost_particle(particle, cell);
});
// the hole and increment a counter.
template <int dim>
void CathodeRaySimulator<dim>::track_lost_particle(
- const typename Particles::ParticleIterator<dim> & particle,
+ const typename Particles::ParticleIterator<dim> &particle,
const typename Triangulation<dim>::active_cell_iterator &cell)
{
++n_recently_lost_particles;
// gnuplot program that we will use for visualization in the results
// section.
void write_dof_locations(const DoFHandler<2> &dof_handler,
- const std::string & filename)
+ const std::string &filename)
{
std::map<types::global_dof_index, Point<2>> dof_location_map =
DoFTools::map_dofs_to_support_points(MappingQ1<2>(), dof_handler);
: Function<dim>(1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
: Function<dim>(1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
{}
virtual void vector_value(const Point<dim> &p,
- Vector<double> & value) const override;
+ Vector<double> &value) const override;
};
template <int dim>
void ExactSolution<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
AssertDimension(values.size(), dim + 1);
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<2, dim>> & values) const override;
+ std::vector<Tensor<2, dim>> &values) const override;
};
// necessary in debug mode.)
template <int dim>
void KInverse<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<2, dim>> & values) const
+ std::vector<Tensor<2, dim>> &values) const
{
(void)points;
AssertDimension(points.size(), values.size());
: Function<dim>(dim + 2)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override
{
return Functions::ZeroFunction<dim>(dim + 2).value(p, component);
}
virtual void vector_value(const Point<dim> &p,
- Vector<double> & values) const override
+ Vector<double> &values) const override
{
Functions::ZeroFunction<dim>(dim + 2).vector_value(p, values);
}
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<2, dim>> & values) const override
+ std::vector<Tensor<2, dim>> &values) const override
{
AssertDimension(points.size(), values.size());
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<2, dim>> & values) const override
+ std::vector<Tensor<2, dim>> &values) const override
{
AssertDimension(points.size(), values.size());
template <int dim>
- std::vector<Point<dim>>
- KInverse<dim>::centers = KInverse<dim>::get_centers();
+ std::vector<Point<dim>> KInverse<dim>::centers =
+ KInverse<dim>::get_centers();
} // namespace RandomMedium
class SchurComplement : public Subscriptor
{
public:
- SchurComplement(const BlockSparseMatrix<double> & A,
+ SchurComplement(const BlockSparseMatrix<double> &A,
const InverseMatrix<SparseMatrix<double>> &Minv)
: system_matrix(&A)
, m_inverse(&Minv)
: Function<dim>(dim + 1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void vector_value(const Point<dim> &p,
- Vector<double> & value) const override;
+ Vector<double> &value) const override;
};
template <int dim>
- double BoundaryValues<dim>::value(const Point<dim> & p,
+ double BoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
template <int dim>
void BoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = BoundaryValues<dim>::value(p, c);
class InverseMatrix : public Subscriptor
{
public:
- InverseMatrix(const MatrixType & m,
+ InverseMatrix(const MatrixType &m,
const PreconditionerType &preconditioner);
void vmult(Vector<double> &dst, const Vector<double> &src) const;
template <class MatrixType, class PreconditionerType>
InverseMatrix<MatrixType, PreconditionerType>::InverseMatrix(
- const MatrixType & m,
+ const MatrixType &m,
const PreconditionerType &preconditioner)
: matrix(&m)
, preconditioner(&preconditioner)
// tolerance, either.
template <class MatrixType, class PreconditionerType>
void InverseMatrix<MatrixType, PreconditionerType>::vmult(
- Vector<double> & dst,
+ Vector<double> &dst,
const Vector<double> &src) const
{
SolverControl solver_control(src.size(), 1e-6 * src.l2_norm());
template <class PreconditionerType>
void
- SchurComplement<PreconditionerType>::vmult(Vector<double> & dst,
+ SchurComplement<PreconditionerType>::vmult(Vector<double> &dst,
const Vector<double> &src) const
{
system_matrix->block(0, 1).vmult(tmp1, src);
class BoundaryValuesU : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override
{
(void)component;
class BoundaryValuesV : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override
{
(void)component;
void assemble_system();
void compute_nl_term(const Vector<double> &old_data,
const Vector<double> &new_data,
- Vector<double> & nl_term) const;
+ Vector<double> &nl_term) const;
void compute_nl_matrix(const Vector<double> &old_data,
const Vector<double> &new_data,
SparseMatrix<double> &nl_matrix) const;
: Function<dim>(n_components, time)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override
{
return ExactSolution<dim>(1, this->get_time()).value(p, component);
, period(0.2)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
template <int dim>
- double RightHandSide<dim>::value(const Point<dim> & p,
+ double RightHandSide<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
class BoundaryValues : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
class RightHandSide : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component) const override;
};
// DoF handler member variables private, and do not have to grant external
// use to it, enhancing encapsulation:
EnergyGroup(const unsigned int group,
- const MaterialData & material_data,
+ const MaterialData &material_data,
const Triangulation<dim> &coarse_grid,
const FiniteElement<dim> &fe);
// coarser of the two cells to the finer one:
private:
void assemble_cross_group_rhs_recursive(
- const EnergyGroup<dim> & g_prime,
+ const EnergyGroup<dim> &g_prime,
const typename DoFHandler<dim>::cell_iterator &cell_g,
const typename DoFHandler<dim>::cell_iterator &cell_g_prime,
- const FullMatrix<double> & prolongation_matrix);
+ const FullMatrix<double> &prolongation_matrix);
};
// members, thereby enabling us to make these data members private.
template <int dim>
EnergyGroup<dim>::EnergyGroup(const unsigned int group,
- const MaterialData & material_data,
+ const MaterialData &material_data,
const Triangulation<dim> &coarse_grid,
const FiniteElement<dim> &fe)
: group(group)
// active. These two cases will be discussed below:
template <int dim>
void EnergyGroup<dim>::assemble_cross_group_rhs_recursive(
- const EnergyGroup<dim> & g_prime,
+ const EnergyGroup<dim> &g_prime,
const typename DoFHandler<dim>::cell_iterator &cell_g,
const typename DoFHandler<dim>::cell_iterator &cell_g_prime,
- const FullMatrix<double> & prolongation_matrix)
+ const FullMatrix<double> &prolongation_matrix)
{
// The first case is that both cells are no further refined. In that case,
// we can assemble the relevant terms (see the introduction). This
// describing the material parameters for the number of energy groups
// requested in the input file, and (iii) the finite element to be used by
// all energy groups:
- const Parameters & parameters;
+ const Parameters ¶meters;
const MaterialData material_data;
FE_Q<dim> fe;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const override
+ std::vector<Vector<double>> &value_list) const override
{
AssertDimension(value_list.size(), points.size());
template <int dim>
void ComputeIntensity<dim>::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
AssertDimension(computed_quantities.size(), inputs.solution_values.size());
{
public:
virtual void value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/ = 0) const override
{
(void)points;
{
public:
virtual void value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/ = 0) const override
{
AssertDimension(values.size(), points.size());
// of a cell. On the other hand, the solution $u(x,y)$ is exactly the same
// as before.
void value_list(const std::vector<Point<dim>> &points,
- std::vector<Point<dim>> & values) const
+ std::vector<Point<dim>> &values) const
{
AssertDimension(values.size(), points.size());
DGTransportEquation();
void assemble_cell_term(const FEValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const;
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const;
void assemble_boundary_term(const FEFaceValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const;
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const;
void assemble_face_term(const FEFaceValuesBase<dim> &fe_v,
const FEFaceValuesBase<dim> &fe_v_neighbor,
- FullMatrix<double> & ui_vi_matrix,
- FullMatrix<double> & ue_vi_matrix,
- FullMatrix<double> & ui_ve_matrix,
- FullMatrix<double> & ue_ve_matrix) const;
+ FullMatrix<double> &ui_vi_matrix,
+ FullMatrix<double> &ue_vi_matrix,
+ FullMatrix<double> &ui_ve_matrix,
+ FullMatrix<double> &ue_ve_matrix) const;
private:
const Beta<dim> beta_function;
template <int dim>
void DGTransportEquation<dim>::assemble_cell_term(
const FEValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const
{
const std::vector<double> &JxW = fe_v.get_JxW_values();
template <int dim>
void DGTransportEquation<dim>::assemble_boundary_term(
const FEFaceValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const
{
- const std::vector<double> & JxW = fe_v.get_JxW_values();
+ const std::vector<double> &JxW = fe_v.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_v.get_normal_vectors();
std::vector<Point<dim>> beta(fe_v.n_quadrature_points);
void DGTransportEquation<dim>::assemble_face_term(
const FEFaceValuesBase<dim> &fe_v,
const FEFaceValuesBase<dim> &fe_v_neighbor,
- FullMatrix<double> & ui_vi_matrix,
- FullMatrix<double> & ue_vi_matrix,
- FullMatrix<double> & ui_ve_matrix,
- FullMatrix<double> & ue_ve_matrix) const
+ FullMatrix<double> &ui_vi_matrix,
+ FullMatrix<double> &ue_vi_matrix,
+ FullMatrix<double> &ui_ve_matrix,
+ FullMatrix<double> &ue_ve_matrix) const
{
- const std::vector<double> & JxW = fe_v.get_JxW_values();
+ const std::vector<double> &JxW = fe_v.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_v.get_normal_vectors();
std::vector<Point<dim>> beta(fe_v.n_quadrature_points);
}
virtual void vector_value(const Point<dim> &p,
- Vector<double> & value) const override
+ Vector<double> &value) const override
{
for (unsigned int c = 0; c < this->n_components; ++c)
value(c) = TemperatureInitialValues<dim>::value(p, c);
: Function<dim>(1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override
{
(void)component;
}
virtual void vector_value(const Point<dim> &p,
- Vector<double> & value) const override
+ Vector<double> &value) const override
{
for (unsigned int c = 0; c < this->n_components; ++c)
value(c) = TemperatureRightHandSide<dim>::value(p, c);
class InverseMatrix : public Subscriptor
{
public:
- InverseMatrix(const MatrixType & m,
+ InverseMatrix(const MatrixType &m,
const PreconditionerType &preconditioner);
private:
const SmartPointer<const MatrixType> matrix;
- const PreconditionerType & preconditioner;
+ const PreconditionerType &preconditioner;
};
template <class MatrixType, class PreconditionerType>
InverseMatrix<MatrixType, PreconditionerType>::InverseMatrix(
- const MatrixType & m,
+ const MatrixType &m,
const PreconditionerType &preconditioner)
: matrix(&m)
, preconditioner(preconditioner)
template <class MatrixType, class PreconditionerType>
template <typename VectorType>
void InverseMatrix<MatrixType, PreconditionerType>::vmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
SolverControl solver_control(src.size(), 1e-7 * src.l2_norm());
const TrilinosWrappers::BlockSparseMatrix &S,
const InverseMatrix<TrilinosWrappers::SparseMatrix,
PreconditionerTypeMp> &Mpinv,
- const PreconditionerTypeA & Apreconditioner);
+ const PreconditionerTypeA &Apreconditioner);
- void vmult(TrilinosWrappers::MPI::BlockVector & dst,
+ void vmult(TrilinosWrappers::MPI::BlockVector &dst,
const TrilinosWrappers::MPI::BlockVector &src) const;
private:
const TrilinosWrappers::BlockSparseMatrix &S,
const InverseMatrix<TrilinosWrappers::SparseMatrix,
PreconditionerTypeMp> &Mpinv,
- const PreconditionerTypeA & Apreconditioner)
+ const PreconditionerTypeA &Apreconditioner)
: stokes_matrix(&S)
, m_inverse(&Mpinv)
, a_preconditioner(Apreconditioner)
template <class PreconditionerTypeA, class PreconditionerTypeMp>
void
BlockSchurPreconditioner<PreconditionerTypeA, PreconditionerTypeMp>::vmult(
- TrilinosWrappers::MPI::BlockVector & dst,
+ TrilinosWrappers::MPI::BlockVector &dst,
const TrilinosWrappers::MPI::BlockVector &src) const
{
a_preconditioner.vmult(dst.block(0), src.block(0));
void refine_mesh(const unsigned int max_grid_level);
double compute_viscosity(
- const std::vector<double> & old_temperature,
- const std::vector<double> & old_old_temperature,
+ const std::vector<double> &old_temperature,
+ const std::vector<double> &old_old_temperature,
const std::vector<Tensor<1, dim>> &old_temperature_grads,
const std::vector<Tensor<1, dim>> &old_old_temperature_grads,
- const std::vector<double> & old_temperature_laplacians,
- const std::vector<double> & old_old_temperature_laplacians,
+ const std::vector<double> &old_temperature_laplacians,
+ const std::vector<double> &old_old_temperature_laplacians,
const std::vector<Tensor<1, dim>> &old_velocity_values,
const std::vector<Tensor<1, dim>> &old_old_velocity_values,
- const std::vector<double> & gamma_values,
+ const std::vector<double> &gamma_values,
const double global_u_infty,
const double global_T_variation,
const double cell_diameter) const;
// discussed in the introduction:
template <int dim>
double BoussinesqFlowProblem<dim>::compute_viscosity(
- const std::vector<double> & old_temperature,
- const std::vector<double> & old_old_temperature,
+ const std::vector<double> &old_temperature,
+ const std::vector<double> &old_old_temperature,
const std::vector<Tensor<1, dim>> &old_temperature_grads,
const std::vector<Tensor<1, dim>> &old_old_temperature_grads,
- const std::vector<double> & old_temperature_laplacians,
- const std::vector<double> & old_old_temperature_laplacians,
+ const std::vector<double> &old_temperature_laplacians,
+ const std::vector<double> &old_old_temperature_laplacians,
const std::vector<Tensor<1, dim>> &old_velocity_values,
const std::vector<Tensor<1, dim>> &old_old_velocity_values,
- const std::vector<double> & gamma_values,
+ const std::vector<double> &gamma_values,
const double global_u_infty,
const double global_T_variation,
const double cell_diameter) const
: Function<dim>(1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void vector_value(const Point<dim> &p,
- Vector<double> & value) const override;
+ Vector<double> &value) const override;
};
template <int dim>
void
TemperatureInitialValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = TemperatureInitialValues<dim>::value(p, c);
BlockSchurPreconditioner(const TrilinosWrappers::BlockSparseMatrix &S,
const TrilinosWrappers::BlockSparseMatrix &Spre,
const PreconditionerTypeMp &Mppreconditioner,
- const PreconditionerTypeA & Apreconditioner,
+ const PreconditionerTypeA &Apreconditioner,
const bool do_solve_A)
: stokes_matrix(&S)
, stokes_preconditioner_matrix(&Spre)
, do_solve_A(do_solve_A)
{}
- void vmult(TrilinosWrappers::MPI::BlockVector & dst,
+ void vmult(TrilinosWrappers::MPI::BlockVector &dst,
const TrilinosWrappers::MPI::BlockVector &src) const
{
TrilinosWrappers::MPI::Vector utmp(src.block(0));
const SmartPointer<const TrilinosWrappers::BlockSparseMatrix>
stokes_preconditioner_matrix;
const PreconditionerTypeMp &mp_preconditioner;
- const PreconditionerTypeA & a_preconditioner;
+ const PreconditionerTypeA &a_preconditioner;
const bool do_solve_A;
};
} // namespace LinearSolvers
struct StokesPreconditioner
{
StokesPreconditioner(const FiniteElement<dim> &stokes_fe,
- const Quadrature<dim> & stokes_quadrature,
- const Mapping<dim> & mapping,
+ const Quadrature<dim> &stokes_quadrature,
+ const Mapping<dim> &mapping,
const UpdateFlags update_flags);
StokesPreconditioner(const StokesPreconditioner &data);
template <int dim>
StokesPreconditioner<dim>::StokesPreconditioner(
const FiniteElement<dim> &stokes_fe,
- const Quadrature<dim> & stokes_quadrature,
- const Mapping<dim> & mapping,
+ const Quadrature<dim> &stokes_quadrature,
+ const Mapping<dim> &mapping,
const UpdateFlags update_flags)
: stokes_fe_values(mapping, stokes_fe, stokes_quadrature, update_flags)
, grad_phi_u(stokes_fe.n_dofs_per_cell())
struct StokesSystem : public StokesPreconditioner<dim>
{
StokesSystem(const FiniteElement<dim> &stokes_fe,
- const Mapping<dim> & mapping,
- const Quadrature<dim> & stokes_quadrature,
+ const Mapping<dim> &mapping,
+ const Quadrature<dim> &stokes_quadrature,
const UpdateFlags stokes_update_flags,
const FiniteElement<dim> &temperature_fe,
const UpdateFlags temperature_update_flags);
template <int dim>
StokesSystem<dim>::StokesSystem(
const FiniteElement<dim> &stokes_fe,
- const Mapping<dim> & mapping,
- const Quadrature<dim> & stokes_quadrature,
+ const Mapping<dim> &mapping,
+ const Quadrature<dim> &stokes_quadrature,
const UpdateFlags stokes_update_flags,
const FiniteElement<dim> &temperature_fe,
const UpdateFlags temperature_update_flags)
struct TemperatureMatrix
{
TemperatureMatrix(const FiniteElement<dim> &temperature_fe,
- const Mapping<dim> & mapping,
- const Quadrature<dim> & temperature_quadrature);
+ const Mapping<dim> &mapping,
+ const Quadrature<dim> &temperature_quadrature);
TemperatureMatrix(const TemperatureMatrix &data);
template <int dim>
TemperatureMatrix<dim>::TemperatureMatrix(
const FiniteElement<dim> &temperature_fe,
- const Mapping<dim> & mapping,
- const Quadrature<dim> & temperature_quadrature)
+ const Mapping<dim> &mapping,
+ const Quadrature<dim> &temperature_quadrature)
: temperature_fe_values(mapping,
temperature_fe,
temperature_quadrature,
{
TemperatureRHS(const FiniteElement<dim> &temperature_fe,
const FiniteElement<dim> &stokes_fe,
- const Mapping<dim> & mapping,
- const Quadrature<dim> & quadrature);
+ const Mapping<dim> &mapping,
+ const Quadrature<dim> &quadrature);
TemperatureRHS(const TemperatureRHS &data);
TemperatureRHS<dim>::TemperatureRHS(
const FiniteElement<dim> &temperature_fe,
const FiniteElement<dim> &stokes_fe,
- const Mapping<dim> & mapping,
- const Quadrature<dim> & quadrature)
+ const Mapping<dim> &mapping,
+ const Quadrature<dim> &quadrature)
: temperature_fe_values(mapping,
temperature_fe,
quadrature,
void refine_mesh(const unsigned int max_grid_level);
double compute_viscosity(
- const std::vector<double> & old_temperature,
- const std::vector<double> & old_old_temperature,
+ const std::vector<double> &old_temperature,
+ const std::vector<double> &old_old_temperature,
const std::vector<Tensor<1, dim>> &old_temperature_grads,
const std::vector<Tensor<1, dim>> &old_old_temperature_grads,
- const std::vector<double> & old_temperature_laplacians,
- const std::vector<double> & old_old_temperature_laplacians,
+ const std::vector<double> &old_temperature_laplacians,
+ const std::vector<double> &old_old_temperature_laplacians,
const std::vector<Tensor<1, dim>> &old_velocity_values,
const std::vector<Tensor<1, dim>> &old_old_velocity_values,
const std::vector<SymmetricTensor<2, dim>> &old_strain_rates,
// in this program. The following eight functions do exactly this:
void local_assemble_stokes_preconditioner(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::StokesPreconditioner<dim> & scratch,
- Assembly::CopyData::StokesPreconditioner<dim> & data);
+ Assembly::Scratch::StokesPreconditioner<dim> &scratch,
+ Assembly::CopyData::StokesPreconditioner<dim> &data);
void copy_local_to_global_stokes_preconditioner(
const Assembly::CopyData::StokesPreconditioner<dim> &data);
void local_assemble_stokes_system(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::StokesSystem<dim> & scratch,
- Assembly::CopyData::StokesSystem<dim> & data);
+ Assembly::Scratch::StokesSystem<dim> &scratch,
+ Assembly::CopyData::StokesSystem<dim> &data);
void copy_local_to_global_stokes_system(
const Assembly::CopyData::StokesSystem<dim> &data);
void local_assemble_temperature_matrix(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::TemperatureMatrix<dim> & scratch,
- Assembly::CopyData::TemperatureMatrix<dim> & data);
+ Assembly::Scratch::TemperatureMatrix<dim> &scratch,
+ Assembly::CopyData::TemperatureMatrix<dim> &data);
void copy_local_to_global_temperature_matrix(
const Assembly::CopyData::TemperatureMatrix<dim> &data);
const double global_max_velocity,
const double global_entropy_variation,
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::TemperatureRHS<dim> & scratch,
- Assembly::CopyData::TemperatureRHS<dim> & data);
+ Assembly::Scratch::TemperatureRHS<dim> &scratch,
+ Assembly::CopyData::TemperatureRHS<dim> &data);
void copy_local_to_global_temperature_rhs(
const Assembly::CopyData::TemperatureRHS<dim> &data);
// updated formulation of the viscosity if $\alpha=2$ is chosen:
template <int dim>
double BoussinesqFlowProblem<dim>::compute_viscosity(
- const std::vector<double> & old_temperature,
- const std::vector<double> & old_old_temperature,
- const std::vector<Tensor<1, dim>> & old_temperature_grads,
- const std::vector<Tensor<1, dim>> & old_old_temperature_grads,
- const std::vector<double> & old_temperature_laplacians,
- const std::vector<double> & old_old_temperature_laplacians,
- const std::vector<Tensor<1, dim>> & old_velocity_values,
- const std::vector<Tensor<1, dim>> & old_old_velocity_values,
+ const std::vector<double> &old_temperature,
+ const std::vector<double> &old_old_temperature,
+ const std::vector<Tensor<1, dim>> &old_temperature_grads,
+ const std::vector<Tensor<1, dim>> &old_old_temperature_grads,
+ const std::vector<double> &old_temperature_laplacians,
+ const std::vector<double> &old_old_temperature_laplacians,
+ const std::vector<Tensor<1, dim>> &old_velocity_values,
+ const std::vector<Tensor<1, dim>> &old_old_velocity_values,
const std::vector<SymmetricTensor<2, dim>> &old_strain_rates,
const std::vector<SymmetricTensor<2, dim>> &old_old_strain_rates,
const double global_u_infty,
template <int dim>
void BoussinesqFlowProblem<dim>::local_assemble_stokes_preconditioner(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::StokesPreconditioner<dim> & scratch,
- Assembly::CopyData::StokesPreconditioner<dim> & data)
+ Assembly::Scratch::StokesPreconditioner<dim> &scratch,
+ Assembly::CopyData::StokesPreconditioner<dim> &data)
{
const unsigned int dofs_per_cell = stokes_fe.n_dofs_per_cell();
const unsigned int n_q_points =
auto worker =
[this](const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::StokesPreconditioner<dim> & scratch,
- Assembly::CopyData::StokesPreconditioner<dim> & data) {
+ Assembly::Scratch::StokesPreconditioner<dim> &scratch,
+ Assembly::CopyData::StokesPreconditioner<dim> &data) {
this->local_assemble_stokes_preconditioner(cell, scratch, data);
};
template <int dim>
void BoussinesqFlowProblem<dim>::local_assemble_stokes_system(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::StokesSystem<dim> & scratch,
- Assembly::CopyData::StokesSystem<dim> & data)
+ Assembly::Scratch::StokesSystem<dim> &scratch,
+ Assembly::CopyData::StokesSystem<dim> &data)
{
const unsigned int dofs_per_cell =
scratch.stokes_fe_values.get_fe().n_dofs_per_cell();
stokes_dof_handler.begin_active()),
CellFilter(IteratorFilters::LocallyOwnedCell(), stokes_dof_handler.end()),
[this](const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::StokesSystem<dim> & scratch,
- Assembly::CopyData::StokesSystem<dim> & data) {
+ Assembly::Scratch::StokesSystem<dim> &scratch,
+ Assembly::CopyData::StokesSystem<dim> &data) {
this->local_assemble_stokes_system(cell, scratch, data);
},
[this](const Assembly::CopyData::StokesSystem<dim> &data) {
template <int dim>
void BoussinesqFlowProblem<dim>::local_assemble_temperature_matrix(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::TemperatureMatrix<dim> & scratch,
- Assembly::CopyData::TemperatureMatrix<dim> & data)
+ Assembly::Scratch::TemperatureMatrix<dim> &scratch,
+ Assembly::CopyData::TemperatureMatrix<dim> &data)
{
const unsigned int dofs_per_cell =
scratch.temperature_fe_values.get_fe().n_dofs_per_cell();
CellFilter(IteratorFilters::LocallyOwnedCell(),
temperature_dof_handler.end()),
[this](const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::TemperatureMatrix<dim> & scratch,
- Assembly::CopyData::TemperatureMatrix<dim> & data) {
+ Assembly::Scratch::TemperatureMatrix<dim> &scratch,
+ Assembly::CopyData::TemperatureMatrix<dim> &data) {
this->local_assemble_temperature_matrix(cell, scratch, data);
},
[this](const Assembly::CopyData::TemperatureMatrix<dim> &data) {
const double global_max_velocity,
const double global_entropy_variation,
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::TemperatureRHS<dim> & scratch,
- Assembly::CopyData::TemperatureRHS<dim> & data)
+ Assembly::Scratch::TemperatureRHS<dim> &scratch,
+ Assembly::CopyData::TemperatureRHS<dim> &data)
{
const bool use_bdf2_scheme = (timestep_number != 0);
auto worker =
[this, global_T_range, maximal_velocity, global_entropy_variation](
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::TemperatureRHS<dim> & scratch,
- Assembly::CopyData::TemperatureRHS<dim> & data) {
+ Assembly::Scratch::TemperatureRHS<dim> &scratch,
+ Assembly::CopyData::TemperatureRHS<dim> &data) {
this->local_assemble_temperature_rhs(global_T_range,
maximal_velocity,
global_entropy_variation,
template <int dim>
void BoussinesqFlowProblem<dim>::Postprocessor::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
const unsigned int n_evaluation_points = inputs.solution_values.size();
Assert(inputs.solution_gradients.size() == n_evaluation_points,
static void compute_flux_matrix(const InputVector &W,
ndarray<typename InputVector::value_type,
EulerEquations<dim>::n_components,
- dim> & flux)
+ dim> &flux)
{
// First compute the pressure that appears in the flux matrix, and then
// compute the first <code>dim</code> columns of the matrix that
// $\alpha$. It's form has also been given already in the introduction:
template <typename InputVector>
static void numerical_normal_flux(
- const Tensor<1, dim> & normal,
- const InputVector & Wplus,
- const InputVector & Wminus,
+ const Tensor<1, dim> &normal,
+ const InputVector &Wplus,
+ const InputVector &Wminus,
const double alpha,
std::array<typename InputVector::value_type, n_components> &normal_flux)
{
// 2d. This naturally leads to the following function:
template <typename InputVector>
static void compute_forcing_vector(
- const InputVector & W,
+ const InputVector &W,
std::array<typename InputVector::value_type, n_components> &forcing)
{
const double gravity = -1.0;
template <typename DataVector>
static void
compute_Wminus(const std::array<BoundaryKind, n_components> &boundary_kind,
- const Tensor<1, dim> & normal_vector,
- const DataVector & Wplus,
+ const Tensor<1, dim> &normal_vector,
+ const DataVector &Wplus,
const Vector<double> &boundary_values,
- const DataVector & Wminus)
+ const DataVector &Wminus)
{
for (unsigned int c = 0; c < n_components; ++c)
switch (boundary_kind[c])
// indicators, but this one does, and it is easy to compute:
static void
compute_refinement_indicators(const DoFHandler<dim> &dof_handler,
- const Mapping<dim> & mapping,
- const Vector<double> & solution,
- Vector<double> & refinement_indicators)
+ const Mapping<dim> &mapping,
+ const Vector<double> &solution,
+ Vector<double> &refinement_indicators)
{
const unsigned int dofs_per_cell = dof_handler.get_fe().n_dofs_per_cell();
std::vector<unsigned int> dofs(dofs_per_cell);
template <int dim>
void EulerEquations<dim>::Postprocessor::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
// At the beginning of the function, let us make sure that all variables
// have the correct sizes, so that we can access individual vector
void setup_system();
void assemble_system();
- void assemble_cell_term(const FEValues<dim> & fe_v,
+ void assemble_cell_term(const FEValues<dim> &fe_v,
const std::vector<types::global_dof_index> &dofs);
void assemble_face_term(
const unsigned int face_no,
- const FEFaceValuesBase<dim> & fe_v,
- const FEFaceValuesBase<dim> & fe_v_neighbor,
+ const FEFaceValuesBase<dim> &fe_v,
+ const FEFaceValuesBase<dim> &fe_v_neighbor,
const std::vector<types::global_dof_index> &dofs,
const std::vector<types::global_dof_index> &dofs_neighbor,
const bool external_face,
// residual:
template <int dim>
void ConservationLaw<dim>::assemble_cell_term(
- const FEValues<dim> & fe_v,
+ const FEValues<dim> &fe_v,
const std::vector<types::global_dof_index> &dof_indices)
{
const unsigned int dofs_per_cell = fe_v.dofs_per_cell;
template <int dim>
void ConservationLaw<dim>::assemble_face_term(
const unsigned int face_no,
- const FEFaceValuesBase<dim> & fe_v,
- const FEFaceValuesBase<dim> & fe_v_neighbor,
+ const FEFaceValuesBase<dim> &fe_v,
+ const FEFaceValuesBase<dim> &fe_v_neighbor,
const std::vector<types::global_dof_index> &dof_indices,
const std::vector<types::global_dof_index> &dof_indices_neighbor,
const bool external_face,
public:
Velocity(const double initial_time = 0.0);
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
template <int dim>
void Velocity<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
const unsigned int n_points = points.size();
public:
Pressure(const double initial_time = 0.0);
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
template <int dim>
- double Pressure<dim>::value(const Point<dim> & p,
+ double Pressure<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
void Pressure<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
(void)component;
unsigned int nqp;
FEValues<dim> fe_val_vel;
FEValues<dim> fe_val_pres;
- InitGradScratchData(const FE_Q<dim> & fe_v,
- const FE_Q<dim> & fe_p,
+ InitGradScratchData(const FE_Q<dim> &fe_v,
+ const FE_Q<dim> &fe_p,
const QGauss<dim> &quad,
const UpdateFlags flags_v,
const UpdateFlags flags_p)
{}
};
- void assemble_one_cell_of_gradient(const IteratorPair & SI,
+ void assemble_one_cell_of_gradient(const IteratorPair &SI,
InitGradScratchData &scratch,
InitGradPerTaskData &data);
std::vector<Tensor<1, dim>> grad_u_star;
std::vector<double> u_star_tmp;
FEValues<dim> fe_val;
- AdvectionScratchData(const FE_Q<dim> & fe,
+ AdvectionScratchData(const FE_Q<dim> &fe,
const QGauss<dim> &quad,
const UpdateFlags flags)
: nqp(quad.size())
void assemble_one_cell_of_advection(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- AdvectionScratchData & scratch,
- AdvectionPerTaskData & data);
+ AdvectionScratchData &scratch,
+ AdvectionPerTaskData &data);
void copy_advection_local_to_global(const AdvectionPerTaskData &data);
template <int dim>
void NavierStokesProjection<dim>::assemble_one_cell_of_gradient(
- const IteratorPair & SI,
+ const IteratorPair &SI,
InitGradScratchData &scratch,
InitGradPerTaskData &data)
{
template <int dim>
void NavierStokesProjection<dim>::assemble_one_cell_of_advection(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- AdvectionScratchData & scratch,
- AdvectionPerTaskData & data)
+ AdvectionScratchData &scratch,
+ AdvectionPerTaskData &data)
{
scratch.fe_val.reinit(cell);
cell->get_dof_indices(data.local_dof_indices);
class Coefficient : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
template <typename number>
template <int dim>
- double Coefficient<dim>::value(const Point<dim> & p,
+ double Coefficient<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
return value<double>(p, component);
private:
virtual void apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const override;
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void local_compute_diagonal(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
- const unsigned int & dummy,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
+ const unsigned int &dummy,
const std::pair<unsigned int, unsigned int> &cell_range) const;
Table<2, VectorizedArray<number>> coefficient;
// degrees of freedom). </ol>
template <int dim, int fe_degree, typename number>
void LaplaceOperator<dim, fe_degree, number>::local_apply(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(data);
// entry of vmult() functions, so no information gets lost.
template <int dim, int fe_degree, typename number>
void LaplaceOperator<dim, fe_degree, number>::apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
this->data->cell_loop(&LaplaceOperator::local_apply, this, dst, src);
// level matrices where no hanging node constraints appear.
template <int dim, int fe_degree, typename number>
void LaplaceOperator<dim, fe_degree, number>::local_compute_diagonal(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
class Solution : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
};
class RightHandSide : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
class MatrixIntegrator : public MeshWorker::LocalIntegrator<dim>
{
public:
- void cell(MeshWorker::DoFInfo<dim> & dinfo,
+ void cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const override;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const override;
- void face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ void face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const override;
};
// LocalIntegrators::Laplace::compute_penalty() and we use this below.
template <int dim>
void MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int degree = info.fe_values(0).get_fe().tensor_degree();
// Interior faces use the interior penalty method
template <int dim>
void MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
class RHSIntegrator : public MeshWorker::LocalIntegrator<dim>
{
public:
- void cell(MeshWorker::DoFInfo<dim> & dinfo,
+ void cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const override;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const override;
- void face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ void face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const override;
};
template <int dim>
void RHSIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
- Vector<double> & local_vector = dinfo.vector(0).block(0);
+ Vector<double> &local_vector = dinfo.vector(0).block(0);
std::vector<double> boundary_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), boundary_values);
class Estimator : public MeshWorker::LocalIntegrator<dim>
{
public:
- void cell(MeshWorker::DoFInfo<dim> & dinfo,
+ void cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const override;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const override;
- void face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ void face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const override;
};
// the right hand side is zero.
template <int dim>
void
- Estimator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+ Estimator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
// the correct boundary condition.
template <int dim>
void Estimator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
// solution and its normal derivative, weighted appropriately.
template <int dim>
void
- Estimator<dim>::face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ Estimator<dim>::face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
- const std::vector<double> & uh1 = info1.values[0][0];
- const std::vector<double> & uh2 = info2.values[0][0];
+ const FEValuesBase<dim> &fe = info1.fe_values();
+ const std::vector<double> &uh1 = info1.values[0][0];
+ const std::vector<double> &uh2 = info2.values[0][0];
const std::vector<Tensor<1, dim>> &Duh1 = info1.gradients[0][0];
const std::vector<Tensor<1, dim>> &Duh2 = info2.gradients[0][0];
class ErrorIntegrator : public MeshWorker::LocalIntegrator<dim>
{
public:
- void cell(MeshWorker::DoFInfo<dim> & dinfo,
+ void cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const override;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const override;
- void face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ void face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const override;
};
// on cells.
template <int dim>
void ErrorIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
- const FEValuesBase<dim> & fe = info.fe_values();
+ const FEValuesBase<dim> &fe = info.fe_values();
std::vector<Tensor<1, dim>> exact_gradients(fe.n_quadrature_points);
std::vector<double> exact_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), exact_values);
const std::vector<Tensor<1, dim>> &Duh = info.gradients[0][0];
- const std::vector<double> & uh = info.values[0][0];
+ const std::vector<double> &uh = info.values[0][0];
for (unsigned k = 0; k < fe.n_quadrature_points; ++k)
{
template <int dim>
void ErrorIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void ErrorIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
+ const FEValuesBase<dim> &fe = info1.fe_values();
const std::vector<double> &uh1 = info1.values[0][0];
const std::vector<double> &uh2 = info2.values[0][0];
class RightHandSide : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
class BoundaryValues : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
class Obstacle : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override
{
(void)component;
bool get_stress_strain_tensor(
const SymmetricTensor<2, dim> &strain_tensor,
- SymmetricTensor<4, dim> & stress_strain_tensor) const;
+ SymmetricTensor<4, dim> &stress_strain_tensor) const;
void get_linearized_stress_strain_tensors(
const SymmetricTensor<2, dim> &strain_tensor,
- SymmetricTensor<4, dim> & stress_strain_tensor_linearized,
- SymmetricTensor<4, dim> & stress_strain_tensor) const;
+ SymmetricTensor<4, dim> &stress_strain_tensor_linearized,
+ SymmetricTensor<4, dim> &stress_strain_tensor) const;
private:
const double kappa;
template <int dim>
bool ConstitutiveLaw<dim>::get_stress_strain_tensor(
const SymmetricTensor<2, dim> &strain_tensor,
- SymmetricTensor<4, dim> & stress_strain_tensor) const
+ SymmetricTensor<4, dim> &stress_strain_tensor) const
{
Assert(dim == 3, ExcNotImplemented());
template <int dim>
void ConstitutiveLaw<dim>::get_linearized_stress_strain_tensors(
const SymmetricTensor<2, dim> &strain_tensor,
- SymmetricTensor<4, dim> & stress_strain_tensor_linearized,
- SymmetricTensor<4, dim> & stress_strain_tensor) const
+ SymmetricTensor<4, dim> &stress_strain_tensor_linearized,
+ SymmetricTensor<4, dim> &stress_strain_tensor) const
{
Assert(dim == 3, ExcNotImplemented());
public:
BoundaryForce();
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void vector_value(const Point<dim> &p,
- Vector<double> & values) const override;
+ Vector<double> &values) const override;
};
template <int dim>
template <int dim>
void BoundaryForce<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = BoundaryForce<dim>::value(p, c);
public:
BoundaryValues();
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
public:
SphereObstacle(const double z_surface);
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void vector_value(const Point<dim> &p,
- Vector<double> & values) const override;
+ Vector<double> &values) const override;
private:
const double z_surface;
template <int dim>
- double SphereObstacle<dim>::value(const Point<dim> & p,
+ double SphereObstacle<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
if (component == 0)
template <int dim>
void SphereObstacle<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = SphereObstacle<dim>::value(p, c);
public:
ChineseObstacle(const std::string &filename, const double z_surface);
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void vector_value(const Point<dim> &p,
- Vector<double> & values) const override;
+ Vector<double> &values) const override;
private:
const BitmapFile<dim> input_obstacle;
template <int dim>
- double ChineseObstacle<dim>::value(const Point<dim> & p,
+ double ChineseObstacle<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
if (component == 0)
template <int dim>
void ChineseObstacle<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = ChineseObstacle<dim>::value(p, c);
: Function<dim>(1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
: Function<dim>(1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
: Function<dim>(1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void vector_value(const Point<dim> &p,
- Vector<double> & value) const override;
+ Vector<double> &value) const override;
};
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<2, dim>> & values) const override;
+ std::vector<Tensor<2, dim>> &values) const override;
};
template <int dim>
void KInverse<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<2, dim>> & values) const
+ std::vector<Tensor<2, dim>> &values) const
{
AssertDimension(points.size(), values.size());
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<2, dim>> & values) const override;
+ std::vector<Tensor<2, dim>> &values) const override;
private:
static std::vector<Point<dim>> centers;
template <int dim>
void KInverse<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<2, dim>> & values) const
+ std::vector<Tensor<2, dim>> &values) const
{
AssertDimension(points.size(), values.size());
class InverseMatrix : public Subscriptor
{
public:
- InverseMatrix(const MatrixType & m,
+ InverseMatrix(const MatrixType &m,
const PreconditionerType &preconditioner);
private:
const SmartPointer<const MatrixType> matrix;
- const PreconditionerType & preconditioner;
+ const PreconditionerType &preconditioner;
};
template <class MatrixType, class PreconditionerType>
InverseMatrix<MatrixType, PreconditionerType>::InverseMatrix(
- const MatrixType & m,
+ const MatrixType &m,
const PreconditionerType &preconditioner)
: matrix(&m)
, preconditioner(preconditioner)
template <class MatrixType, class PreconditionerType>
template <typename VectorType>
void InverseMatrix<MatrixType, PreconditionerType>::vmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
SolverControl solver_control(src.size(), 1e-7 * src.l2_norm());
const TrilinosWrappers::BlockSparseMatrix &S,
const InverseMatrix<TrilinosWrappers::SparseMatrix,
PreconditionerTypeMp> &Mpinv,
- const PreconditionerTypeA & Apreconditioner);
+ const PreconditionerTypeA &Apreconditioner);
- void vmult(TrilinosWrappers::MPI::BlockVector & dst,
+ void vmult(TrilinosWrappers::MPI::BlockVector &dst,
const TrilinosWrappers::MPI::BlockVector &src) const;
private:
const TrilinosWrappers::BlockSparseMatrix &S,
const InverseMatrix<TrilinosWrappers::SparseMatrix,
PreconditionerTypeMp> &Mpinv,
- const PreconditionerTypeA & Apreconditioner)
+ const PreconditionerTypeA &Apreconditioner)
: darcy_matrix(&S)
, m_inverse(&Mpinv)
, a_preconditioner(Apreconditioner)
template <class PreconditionerTypeA, class PreconditionerTypeMp>
void
BlockSchurPreconditioner<PreconditionerTypeA, PreconditionerTypeMp>::vmult(
- TrilinosWrappers::MPI::BlockVector & dst,
+ TrilinosWrappers::MPI::BlockVector &dst,
const TrilinosWrappers::MPI::BlockVector &src) const
{
a_preconditioner.vmult(dst.block(0), src.block(0));
void assemble_saturation_matrix();
void assemble_saturation_rhs();
void assemble_saturation_rhs_cell_term(
- const FEValues<dim> & saturation_fe_values,
- const FEValues<dim> & darcy_fe_values,
+ const FEValues<dim> &saturation_fe_values,
+ const FEValues<dim> &darcy_fe_values,
const double global_max_u_F_prime,
const double global_S_variation,
const std::vector<types::global_dof_index> &local_dof_indices);
void assemble_saturation_rhs_boundary_term(
- const FEFaceValues<dim> & saturation_fe_face_values,
- const FEFaceValues<dim> & darcy_fe_face_values,
+ const FEFaceValues<dim> &saturation_fe_face_values,
+ const FEFaceValues<dim> &darcy_fe_face_values,
const std::vector<types::global_dof_index> &local_dof_indices);
void solve();
void refine_mesh(const unsigned int min_grid_level,
bool determine_whether_to_solve_for_pressure_and_velocity() const;
void project_back_saturation();
double compute_viscosity(
- const std::vector<double> & old_saturation,
- const std::vector<double> & old_old_saturation,
+ const std::vector<double> &old_saturation,
+ const std::vector<double> &old_old_saturation,
const std::vector<Tensor<1, dim>> &old_saturation_grads,
const std::vector<Tensor<1, dim>> &old_old_saturation_grads,
const std::vector<Vector<double>> &present_darcy_values,
// global vector with position specified in local_dof_indices.
template <int dim>
void TwoPhaseFlowProblem<dim>::assemble_saturation_rhs_cell_term(
- const FEValues<dim> & saturation_fe_values,
- const FEValues<dim> & darcy_fe_values,
+ const FEValues<dim> &saturation_fe_values,
+ const FEValues<dim> &darcy_fe_values,
const double global_max_u_F_prime,
const double global_S_variation,
const std::vector<types::global_dof_index> &local_dof_indices)
// from giving more descriptions about that.
template <int dim>
void TwoPhaseFlowProblem<dim>::assemble_saturation_rhs_boundary_term(
- const FEFaceValues<dim> & saturation_fe_face_values,
- const FEFaceValues<dim> & darcy_fe_face_values,
+ const FEFaceValues<dim> &saturation_fe_face_values,
+ const FEFaceValues<dim> &darcy_fe_face_values,
const std::vector<types::global_dof_index> &local_dof_indices)
{
const unsigned int dofs_per_cell = saturation_fe_face_values.dofs_per_cell;
// need to be adjusted accordingly.
template <int dim>
double TwoPhaseFlowProblem<dim>::compute_viscosity(
- const std::vector<double> & old_saturation,
- const std::vector<double> & old_old_saturation,
+ const std::vector<double> &old_saturation,
+ const std::vector<double> &old_old_saturation,
const std::vector<Tensor<1, dim>> &old_saturation_grads,
const std::vector<Tensor<1, dim>> &old_old_saturation_grads,
const std::vector<Vector<double>> &present_darcy_values,
void assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_ASM & scratch,
- PerTaskData_ASM & data) const;
+ ScratchData_ASM &scratch,
+ PerTaskData_ASM &data) const;
// And similar to perform global static condensation:
void assemble_sc();
void assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void copy_local_to_global_sc(const PerTaskData_SC &data);
void update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
- PerTaskData_UQPH & data);
+ ScratchData_UQPH &scratch,
+ PerTaskData_UQPH &data);
void copy_local_to_global_UQPH(const PerTaskData_UQPH & /*data*/)
{}
void get_error_residual(Errors &error_residual);
void get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double> get_error_dilation() const;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_ASM(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face)
: fe_values(fe_cell, qf_cell, uf_cell)
, fe_face_values(fe_cell, qf_face, uf_face)
FEValues<dim> fe_values;
- ScratchData_UQPH(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_UQPH(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
template <int dim>
void Solid<dim>::update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
+ ScratchData_UQPH &scratch,
PerTaskData_UQPH & /*data*/)
{
const std::vector<std::shared_ptr<PointHistory<dim>>> lqph =
// Determine the true Newton update error for the problem
template <int dim>
void Solid<dim>::get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler.n_dofs(); ++i)
WorkStream::run(
dof_handler.active_cell_iterators(),
[this](const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_ASM & scratch,
- PerTaskData_ASM & data) {
+ ScratchData_ASM &scratch,
+ PerTaskData_ASM &data) {
this->assemble_system_one_cell(cell, scratch, data);
},
[this](const PerTaskData_ASM &data) {
template <int dim>
void Solid<dim>::assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_ASM & scratch,
- PerTaskData_ASM & data) const
+ ScratchData_ASM &scratch,
+ PerTaskData_ASM &data) const
{
data.reset();
scratch.reset();
// Next we define some aliases to make the assembly process easier to
// follow.
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const std::vector<Tensor<2, dim>> &grad_Nx = scratch.grad_Nx[q_point];
template <int dim>
void Solid<dim>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
: Function<dim>(dim + 1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void vector_value(const Point<dim> &p,
- Vector<double> & value) const override;
+ Vector<double> &value) const override;
};
template <int dim>
void BoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = BoundaryValues<dim>::value(p, c);
: Function<dim>(dim + 1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void vector_value(const Point<dim> &p,
- Vector<double> & value) const override;
+ Vector<double> &value) const override;
};
template <int dim>
- double RightHandSide<dim>::value(const Point<dim> & p,
+ double RightHandSide<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
const Point<dim> center(0.75, 0.1);
template <int dim>
void RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = RightHandSide<dim>::value(p, c);
class InverseMatrix : public Subscriptor
{
public:
- InverseMatrix(const MatrixType & m,
+ InverseMatrix(const MatrixType &m,
const PreconditionerType &preconditioner,
- const IndexSet & locally_owned,
+ const IndexSet &locally_owned,
const MPI_Comm mpi_communicator);
- void vmult(TrilinosWrappers::MPI::Vector & dst,
+ void vmult(TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const;
private:
template <class MatrixType, class PreconditionerType>
InverseMatrix<MatrixType, PreconditionerType>::InverseMatrix(
- const MatrixType & m,
+ const MatrixType &m,
const PreconditionerType &preconditioner,
- const IndexSet & locally_owned,
+ const IndexSet &locally_owned,
const MPI_Comm mpi_communicator)
: matrix(&m)
, preconditioner(&preconditioner)
template <class MatrixType, class PreconditionerType>
void InverseMatrix<MatrixType, PreconditionerType>::vmult(
- TrilinosWrappers::MPI::Vector & dst,
+ TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const
{
SolverControl solver_control(src.size(), 1e-6 * src.l2_norm());
public:
SchurComplement(const TrilinosWrappers::BlockSparseMatrix &system_matrix,
const InverseMatrix<TrilinosWrappers::SparseMatrix,
- PreconditionerType> & A_inverse,
- const IndexSet & owned_pres,
+ PreconditionerType> &A_inverse,
+ const IndexSet &owned_pres,
const MPI_Comm mpi_communicator);
- void vmult(TrilinosWrappers::MPI::Vector & dst,
+ void vmult(TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const;
private:
SchurComplement<PreconditionerType>::SchurComplement(
const TrilinosWrappers::BlockSparseMatrix &system_matrix,
const InverseMatrix<TrilinosWrappers::SparseMatrix, PreconditionerType>
- & A_inverse,
+ &A_inverse,
const IndexSet &owned_vel,
const MPI_Comm mpi_communicator)
: system_matrix(&system_matrix)
template <class PreconditionerType>
void SchurComplement<PreconditionerType>::vmult(
- TrilinosWrappers::MPI::Vector & dst,
+ TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const
{
system_matrix->block(0, 1).vmult(tmp1, src);
void setup_dofs();
void assemble_system();
void assemble_interface_term(
- const FEFaceValuesBase<dim> & elasticity_fe_face_values,
- const FEFaceValuesBase<dim> & stokes_fe_face_values,
- std::vector<Tensor<1, dim>> & elasticity_phi,
+ const FEFaceValuesBase<dim> &elasticity_fe_face_values,
+ const FEFaceValuesBase<dim> &stokes_fe_face_values,
+ std::vector<Tensor<1, dim>> &elasticity_phi,
std::vector<SymmetricTensor<2, dim>> &stokes_symgrad_phi_u,
- std::vector<double> & stokes_phi_p,
- FullMatrix<double> & local_interface_matrix) const;
+ std::vector<double> &stokes_phi_p,
+ FullMatrix<double> &local_interface_matrix) const;
void solve();
void output_results(const unsigned int refinement_cycle) const;
void refine_mesh();
: Function<dim>(dim + 1 + dim)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void vector_value(const Point<dim> &p,
- Vector<double> & value) const override;
+ Vector<double> &value) const override;
};
template <int dim>
- double StokesBoundaryValues<dim>::value(const Point<dim> & p,
+ double StokesBoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
template <int dim>
void StokesBoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = StokesBoundaryValues<dim>::value(p, c);
// here are given in the introduction.
template <int dim>
void FluidStructureProblem<dim>::assemble_interface_term(
- const FEFaceValuesBase<dim> & elasticity_fe_face_values,
- const FEFaceValuesBase<dim> & stokes_fe_face_values,
- std::vector<Tensor<1, dim>> & elasticity_phi,
+ const FEFaceValuesBase<dim> &elasticity_fe_face_values,
+ const FEFaceValuesBase<dim> &stokes_fe_face_values,
+ std::vector<Tensor<1, dim>> &elasticity_phi,
std::vector<SymmetricTensor<2, dim>> &stokes_symgrad_phi_u,
- std::vector<double> & stokes_phi_p,
- FullMatrix<double> & local_interface_matrix) const
+ std::vector<double> &stokes_phi_p,
+ FullMatrix<double> &local_interface_matrix) const
{
Assert(stokes_fe_face_values.n_quadrature_points ==
elasticity_fe_face_values.n_quadrature_points,
}
virtual void
- hessian_list(const std::vector<Point<dim>> & points,
+ hessian_list(const std::vector<Point<dim>> &points,
std::vector<SymmetricTensor<2, dim>> &hessians,
const unsigned int /*component*/ = 0) const override
{
template <int dim>
struct ScratchData
{
- ScratchData(const Mapping<dim> & mapping,
+ ScratchData(const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
const unsigned int quadrature_degree,
const UpdateFlags update_flags,
// we could have left the call to `fe_values.shape_hessian(j,qpoint)`
// in the instruction that computes the scalar product between
// the two terms.
- auto cell_worker = [&](const Iterator & cell,
+ auto cell_worker = [&](const Iterator &cell,
ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
copy_data.cell_matrix = 0;
copy_data.cell_rhs = 0;
// `copy_data.face_data()` is really all that the later `copier` function
// gets to see when it copies the contributions of each cell to the global
// matrix and right hand side objects.
- auto face_worker = [&](const Iterator & cell,
+ auto face_worker = [&](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
FEInterfaceValues<dim> &fe_interface_values =
scratch_data.fe_interface_values;
fe_interface_values.reinit(cell, f, sf, ncell, nf, nsf);
//
// As before, the first part of the function simply sets up some
// helper objects:
- auto boundary_worker = [&](const Iterator & cell,
+ auto boundary_worker = [&](const Iterator &cell,
const unsigned int &face_no,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
FEInterfaceValues<dim> &fe_interface_values =
scratch_data.fe_interface_values;
fe_interface_values.reinit(cell, face_no);
&src) const;
private:
- const MatrixFree<dim, double> & data;
+ const MatrixFree<dim, double> &data;
const VectorizedArray<double> delta_t_sqr;
LinearAlgebra::distributed::Vector<double> inv_mass_matrix;
void local_apply(
- const MatrixFree<dim, double> & data,
- LinearAlgebra::distributed::Vector<double> & dst,
+ const MatrixFree<dim, double> &data,
+ LinearAlgebra::distributed::Vector<double> &dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
};
// dst.
template <int dim, int fe_degree>
void SineGordonOperation<dim, fe_degree>::local_apply(
- const MatrixFree<dim> & data,
- LinearAlgebra::distributed::Vector<double> & dst,
+ 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
{
// inverse mass matrix.
template <int dim, int fe_degree>
void SineGordonOperation<dim, fe_degree>::apply(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src) const
{
data.cell_loop(
// visualized in Paraview or VisIt.
template <int dim>
void print_mesh_info(const Triangulation<dim> &triangulation,
- const std::string & filename)
+ const std::string &filename)
{
std::cout << "Mesh info:" << std::endl
<< " dimension: " << dim << std::endl
namespace ChangeVectorTypes
{
template <typename number>
- void copy(LA::MPI::Vector & out,
+ void copy(LA::MPI::Vector &out,
const LinearAlgebra::distributed::Vector<number> &in)
{
LinearAlgebra::ReadWriteVector<double> rwv(out.locally_owned_elements());
template <typename number>
void copy(LinearAlgebra::distributed::Vector<number> &out,
- const LA::MPI::Vector & in)
+ const LA::MPI::Vector &in)
{
LinearAlgebra::ReadWriteVector<double> rwv;
#ifdef USE_PETSC_LA
template <int dim>
struct ScratchData
{
- ScratchData(const Mapping<dim> & mapping,
+ ScratchData(const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
const unsigned int quadrature_degree,
const UpdateFlags update_flags,
using Iterator = typename DoFHandler<dim>::active_cell_iterator;
// Assembler for cell residual $h^2 \| f + \epsilon \triangle u \|_K^2$
- auto cell_worker = [&](const Iterator & cell,
+ auto cell_worker = [&](const Iterator &cell,
ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
FEValues<dim> &fe_values = scratch_data.fe_values;
fe_values.reinit(cell);
// Assembler for face term $\sum_F h_F \| \jump{\epsilon \nabla u \cdot n}
// \|_F^2$
- auto face_worker = [&](const Iterator & cell,
+ auto face_worker = [&](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
FEInterfaceValues<dim> &fe_interface_values =
scratch_data.fe_interface_values;
fe_interface_values.reinit(cell, f, sf, ncell, nf, nsf);
{}
virtual void vector_value(const Point<dim> &p,
- Vector<double> & v) const override
+ Vector<double> &v) const override
{
AssertDimension(v.size(), dim + 1);
Solution<dim> solution;
// work of the program.
void assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData & scratch,
- PerTaskData & task_data);
+ ScratchData &scratch,
+ PerTaskData &task_data);
void copy_local_to_global(const PerTaskData &data);
void postprocess_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- PostProcessScratchData & scratch,
- unsigned int & empty_data);
+ PostProcessScratchData &scratch,
+ unsigned int &empty_data);
Triangulation<dim> triangulation;
ScratchData(const FiniteElement<dim> &fe,
const FiniteElement<dim> &fe_local,
- const QGauss<dim> & quadrature_formula,
- const QGauss<dim - 1> & face_quadrature_formula,
+ const QGauss<dim> &quadrature_formula,
+ const QGauss<dim - 1> &face_quadrature_formula,
const UpdateFlags local_flags,
const UpdateFlags local_face_flags,
const UpdateFlags flags)
PostProcessScratchData(const FiniteElement<dim> &fe,
const FiniteElement<dim> &fe_local,
- const QGauss<dim> & quadrature_formula,
+ const QGauss<dim> &quadrature_formula,
const UpdateFlags local_flags,
const UpdateFlags flags)
: fe_values_local(fe_local, quadrature_formula, local_flags)
template <int dim>
void HDG<dim>::assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData & scratch,
- PerTaskData & task_data)
+ ScratchData &scratch,
+ PerTaskData &task_data)
{
// Construct iterator for dof_handler_local for FEValues reinit function.
const typename DoFHandler<dim>::active_cell_iterator loc_cell =
dof_handler_u_post.begin_active(),
dof_handler_u_post.end(),
[this](const typename DoFHandler<dim>::active_cell_iterator &cell,
- PostProcessScratchData & scratch,
- unsigned int & data) {
+ PostProcessScratchData &scratch,
+ unsigned int &data) {
this->postprocess_one_cell(cell, scratch, data);
},
std::function<void(const unsigned int &)>(),
template <int dim>
void HDG<dim>::postprocess_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- PostProcessScratchData & scratch,
+ PostProcessScratchData &scratch,
unsigned int &)
{
const typename DoFHandler<dim>::active_cell_iterator loc_cell =
TriangulationOnCAD(
- const std::string & initial_mesh_filename,
- const std::string & cad_file_name,
- const std::string & output_filename,
+ const std::string &initial_mesh_filename,
+ const std::string &cad_file_name,
+ const std::string &output_filename,
const ProjectionType surface_projection_kind = NormalProjection);
void run();
// below for details).
TriangulationOnCAD::TriangulationOnCAD(
- const std::string & initial_mesh_filename,
- const std::string & cad_file_name,
- const std::string & output_filename,
+ const std::string &initial_mesh_filename,
+ const std::string &cad_file_name,
+ const std::string &output_filename,
const ProjectionType surface_projection_kind)
: initial_mesh_filename(initial_mesh_filename)
, cad_file_name(cad_file_name)
private:
const SmartPointer<const Matrix> matrix;
- const Preconditioner & preconditioner;
+ const Preconditioner &preconditioner;
};
template <class Matrix, class Preconditioner>
InverseMatrix<Matrix, Preconditioner>::InverseMatrix(
- const Matrix & m,
+ const Matrix &m,
const Preconditioner &preconditioner)
: matrix(&m)
, preconditioner(preconditioner)
template <class Matrix, class Preconditioner>
template <typename VectorType>
void
- InverseMatrix<Matrix, Preconditioner>::vmult(VectorType & dst,
+ InverseMatrix<Matrix, Preconditioner>::vmult(VectorType &dst,
const VectorType &src) const
{
SolverControl solver_control(src.size(), 1e-8 * src.l2_norm());
BlockDiagonalPreconditioner(const PreconditionerA &preconditioner_A,
const PreconditionerS &preconditioner_S);
- void vmult(LA::MPI::BlockVector & dst,
+ void vmult(LA::MPI::BlockVector &dst,
const LA::MPI::BlockVector &src) const;
private:
template <class PreconditionerA, class PreconditionerS>
void BlockDiagonalPreconditioner<PreconditionerA, PreconditionerS>::vmult(
- LA::MPI::BlockVector & dst,
+ LA::MPI::BlockVector &dst,
const LA::MPI::BlockVector &src) const
{
preconditioner_A.vmult(dst.block(0), src.block(0));
{}
virtual void vector_value(const Point<dim> &p,
- Vector<double> & value) const override;
+ Vector<double> &value) const override;
};
template <int dim>
void RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
const double R_x = p[0];
const double R_y = p[1];
{}
virtual void vector_value(const Point<dim> &p,
- Vector<double> & values) const override;
+ Vector<double> &values) const override;
};
template <int dim>
void ExactSolution<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
const double R_x = p[0];
const double R_y = p[1];
Solution()
: Function<dim>(dim + 1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
};
template <>
- double Solution<2>::value(const Point<2> & p,
+ double Solution<2>::value(const Point<2> &p,
const unsigned int component) const
{
Assert(component <= 2 + 1, ExcIndexRange(component, 0, 2 + 1));
}
template <>
- double Solution<3>::value(const Point<3> & p,
+ double Solution<3>::value(const Point<3> &p,
const unsigned int component) const
{
Assert(component <= 3 + 1, ExcIndexRange(component, 0, 3 + 1));
// Note that for the gradient we need to return a Tensor<1,dim>
template <>
- Tensor<1, 2> Solution<2>::gradient(const Point<2> & p,
+ Tensor<1, 2> Solution<2>::gradient(const Point<2> &p,
const unsigned int component) const
{
Assert(component <= 2, ExcIndexRange(component, 0, 2 + 1));
}
template <>
- Tensor<1, 3> Solution<3>::gradient(const Point<3> & p,
+ Tensor<1, 3> Solution<3>::gradient(const Point<3> &p,
const unsigned int component) const
{
Assert(component <= 3, ExcIndexRange(component, 0, 3 + 1));
: Function<dim>(dim + 1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
template <>
- double RightHandSide<2>::value(const Point<2> & p,
+ double RightHandSide<2>::value(const Point<2> &p,
const unsigned int component) const
{
Assert(component <= 2, ExcIndexRange(component, 0, 2 + 1));
}
template <>
- double RightHandSide<3>::value(const Point<3> & p,
+ double RightHandSide<3>::value(const Point<3> &p,
const unsigned int component) const
{
Assert(component <= 3, ExcIndexRange(component, 0, 3 + 1));
public:
BlockSchurPreconditioner(
const BlockSparseMatrix<double> &system_matrix,
- const SparseMatrix<double> & schur_complement_matrix,
- const PreconditionerAType & preconditioner_A,
- const PreconditionerSType & preconditioner_S,
+ const SparseMatrix<double> &schur_complement_matrix,
+ const PreconditionerAType &preconditioner_A,
+ const PreconditionerSType &preconditioner_S,
const bool do_solve_A);
void vmult(BlockVector<double> &dst, const BlockVector<double> &src) const;
private:
const BlockSparseMatrix<double> &system_matrix;
- const SparseMatrix<double> & schur_complement_matrix;
- const PreconditionerAType & preconditioner_A;
- const PreconditionerSType & preconditioner_S;
+ const SparseMatrix<double> &schur_complement_matrix;
+ const PreconditionerAType &preconditioner_A;
+ const PreconditionerSType &preconditioner_S;
const bool do_solve_A;
};
BlockSchurPreconditioner<PreconditionerAType, PreconditionerSType>::
BlockSchurPreconditioner(
const BlockSparseMatrix<double> &system_matrix,
- const SparseMatrix<double> & schur_complement_matrix,
- const PreconditionerAType & preconditioner_A,
- const PreconditionerSType & preconditioner_S,
+ const SparseMatrix<double> &schur_complement_matrix,
+ const PreconditionerAType &preconditioner_A,
+ const PreconditionerSType &preconditioner_S,
const bool do_solve_A)
: n_iterations_A(0)
, n_iterations_S(0)
template <class PreconditionerAType, class PreconditionerSType>
void
BlockSchurPreconditioner<PreconditionerAType, PreconditionerSType>::vmult(
- BlockVector<double> & dst,
+ BlockVector<double> &dst,
const BlockVector<double> &src) const
{
Vector<double> utmp(src.block(0));
BoundaryValues()
: Function<dim>(dim + 1)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component) const override;
};
template <int dim>
- double BoundaryValues<dim>::value(const Point<dim> & p,
+ double BoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
BlockSchurPreconditioner(double gamma,
double viscosity,
const BlockSparseMatrix<double> &S,
- const SparseMatrix<double> & P,
- const PreconditionerMp & Mppreconditioner);
+ const SparseMatrix<double> &P,
+ const PreconditionerMp &Mppreconditioner);
void vmult(BlockVector<double> &dst, const BlockVector<double> &src) const;
const double gamma;
const double viscosity;
const BlockSparseMatrix<double> &stokes_matrix;
- const SparseMatrix<double> & pressure_mass_matrix;
- const PreconditionerMp & mp_preconditioner;
+ const SparseMatrix<double> &pressure_mass_matrix;
+ const PreconditionerMp &mp_preconditioner;
SparseDirectUMFPACK A_inverse;
};
double gamma,
double viscosity,
const BlockSparseMatrix<double> &S,
- const SparseMatrix<double> & P,
- const PreconditionerMp & Mppreconditioner)
+ const SparseMatrix<double> &P,
+ const PreconditionerMp &Mppreconditioner)
: gamma(gamma)
, viscosity(viscosity)
, stokes_matrix(S)
template <class PreconditionerMp>
void BlockSchurPreconditioner<PreconditionerMp>::vmult(
- BlockVector<double> & dst,
+ BlockVector<double> &dst,
const BlockVector<double> &src) const
{
Vector<double> utmp(src.block(0));
template <int dim>
std::complex<double>
- InitialValues<dim>::value(const Point<dim> & p,
+ InitialValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
static_assert(dim == 2, "This initial condition only works in 2d.");
{
public:
Potential() = default;
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
template <int dim>
- double Potential<dim>::value(const Point<dim> & p,
+ double Potential<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
void ComplexAmplitude<dim>::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
AssertDimension(computed_quantities.size(),
inputs.solution_values.size());
template <int dim>
void ComplexPhase<dim>::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
AssertDimension(computed_quantities.size(),
inputs.solution_values.size());
std::shared_ptr<const MatrixFree<dim, number>> get_matrix_free() const;
- void vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ void vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const;
- void Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ void Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const;
number get_penalty_factor() const
private:
void
- apply_cell(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ apply_cell(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
- apply_face(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ apply_face(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &face_range) const;
void apply_boundary(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const;
+ const std::pair<unsigned int, unsigned int> &face_range) const;
std::shared_ptr<const MatrixFree<dim, number>> data;
};
void initialize(const LaplaceOperator<dim, fe_degree, number> &op);
- void vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ void vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const;
- void Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ void Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult(dst, src);
template <int dim, typename number>
void adjust_ghost_range_if_necessary(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
const LinearAlgebra::distributed::Vector<number> &vec)
{
if (vec.get_partitioner().get() ==
template <int dim, int fe_degree, typename number>
void LaplaceOperator<dim, fe_degree, number>::vmult(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
adjust_ghost_range_if_necessary(*data, dst);
template <int dim, int fe_degree, typename number>
void LaplaceOperator<dim, fe_degree, number>::Tvmult(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult(dst, src);
template <int dim, int fe_degree, typename number>
void LaplaceOperator<dim, fe_degree, number>::apply_cell(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(data);
for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
template <int dim, int fe_degree, typename number>
void LaplaceOperator<dim, fe_degree, number>::apply_face(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi_inner(data,
true);
template <int dim, int fe_degree, typename number>
void LaplaceOperator<dim, fe_degree, number>::apply_boundary(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi_inner(data,
true);
template <int dim, int fe_degree, typename number>
void PreconditionBlockJacobi<dim, fe_degree, number>::vmult(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
adjust_ghost_range_if_necessary(*data, dst);
template <int dim>
void Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<2, dim>> & values) const
+ std::vector<Tensor<2, dim>> &values) const
{
AssertDimension(points.size(), values.size());
for (unsigned int p = 0; p < points.size(); ++p)
: Function<dim>(2)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
class RightHandSide : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
: Function<dim>(2)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component) const override;
};
public:
RightHandSide(HDF5::Group &data);
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component) const override;
private:
public:
Rho(HDF5::Group &data);
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
// that the pulse has been cropped to $x_\textrm{min}<x<x_\textrm{max}$ and
// $y_\textrm{min} <y<y_\textrm{max}$.
template <int dim>
- double RightHandSide<dim>::value(const Point<dim> & p,
+ double RightHandSide<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
if (component == force_component)
// The PML coefficient for the `x` component takes the form
// $s'_x = a_x x^{\textrm{degree}}$
template <int dim>
- std::complex<double> PML<dim>::value(const Point<dim> & p,
+ std::complex<double> PML<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
double calculated_pml_x_coeff = 0;
class RightHandSide : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
template <int dim>
void RightHandSide<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
AssertDimension(values.size(), points.size());
class BoundaryValues : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
template <int dim>
- double BoundaryValues<dim>::value(const Point<dim> & p,
+ double BoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component == 0, ExcIndexRange(component, 0, 1));
template <int dim>
void BoundaryValues<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
AssertDimension(values.size(), points.size());
template <class IteratorType>
void assemble_cell(const IteratorType &cell,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data);
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data);
void assemble_system_and_multigrid();
void setup_smoother();
template <int dim>
template <class IteratorType>
void AdvectionProblem<dim>::assemble_cell(const IteratorType &cell,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data)
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data)
{
copy_data.level = cell->level();
{
const auto cell_worker_active =
[&](const decltype(dof_handler.begin_active()) &cell,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
this->assemble_cell(cell, scratch_data, copy_data);
};
const auto cell_worker_mg =
[&](const decltype(dof_handler.begin_mg()) &cell,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
this->assemble_cell(cell, scratch_data, copy_data);
};
public:
DEAL_II_HOST_DEVICE HelmholtzOperatorQuad(
const typename CUDAWrappers::MatrixFree<dim, double>::Data *gpu_data,
- double * coef,
+ double *coef,
int cell)
: gpu_data(gpu_data)
, coef(coef)
DEAL_II_HOST_DEVICE void operator()(
CUDAWrappers::FEEvaluation<dim, fe_degree, fe_degree + 1, 1, double>
- * fe_eval,
+ *fe_eval,
const int q_point) const;
static const unsigned int n_q_points =
private:
const typename CUDAWrappers::MatrixFree<dim, double>::Data *gpu_data;
- double * coef;
+ double *coef;
int cell;
};
template <int dim, int fe_degree>
DEAL_II_HOST_DEVICE void HelmholtzOperatorQuad<dim, fe_degree>::operator()(
CUDAWrappers::FEEvaluation<dim, fe_degree, fe_degree + 1, 1, double>
- * fe_eval,
+ *fe_eval,
const int q_point) const
{
const unsigned int pos =
DEAL_II_HOST_DEVICE void operator()(
const unsigned int cell,
const typename CUDAWrappers::MatrixFree<dim, double>::Data *gpu_data,
- CUDAWrappers::SharedData<dim, double> * shared_data,
- const double * src,
- double * dst) const;
+ CUDAWrappers::SharedData<dim, double> *shared_data,
+ const double *src,
+ double *dst) const;
private:
double *coef;
DEAL_II_HOST_DEVICE void LocalHelmholtzOperator<dim, fe_degree>::operator()(
const unsigned int cell,
const typename CUDAWrappers::MatrixFree<dim, double>::Data *gpu_data,
- CUDAWrappers::SharedData<dim, double> * shared_data,
- const double * src,
- double * dst) const
+ CUDAWrappers::SharedData<dim, double> *shared_data,
+ const double *src,
+ double *dst) const
{
CUDAWrappers::FEEvaluation<dim, fe_degree, fe_degree + 1, 1, double>
fe_eval(gpu_data, shared_data);
class HelmholtzOperator
{
public:
- HelmholtzOperator(const DoFHandler<dim> & dof_handler,
+ HelmholtzOperator(const DoFHandler<dim> &dof_handler,
const AffineConstraints<double> &constraints);
void
// parallel:distributed::Triangulation object in fact.
template <int dim, int fe_degree>
HelmholtzOperator<dim, fe_degree>::HelmholtzOperator(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<double> &constraints)
{
MappingQ<dim> mapping(fe_degree);
// destination vector afterwards.
template <int dim, int fe_degree>
void HelmholtzOperator<dim, fe_degree>::vmult(
- LinearAlgebra::distributed::Vector<double, MemorySpace::Default> & dst,
+ LinearAlgebra::distributed::Vector<double, MemorySpace::Default> &dst,
const LinearAlgebra::distributed::Vector<double, MemorySpace::Default> &src)
const
{
private:
virtual void apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const override;
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
// the global vector <code> dst</code>.
template <int dim, int fe_degree, typename number>
void JacobianOperator<dim, fe_degree, number>::local_apply(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FECellIntegrator phi(data);
// cells computing the cell contribution to the matrix-vector product.
template <int dim, int fe_degree, typename number>
void JacobianOperator<dim, fe_degree, number>::apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
this->data->cell_loop(&JacobianOperator::local_apply, this, dst, src);
void setup_system();
void evaluate_residual(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const;
void local_evaluate_residual(
- const MatrixFree<dim, double> & data,
- LinearAlgebra::distributed::Vector<double> & dst,
+ const MatrixFree<dim, double> &data,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
void assemble_rhs();
// MatrixFree::cell_loop().
template <int dim, int fe_degree>
void GelfandProblem<dim, fe_degree>::evaluate_residual(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
auto matrix_free = system_matrix.get_matrix_free();
// the input vector might have constrained DOFs.
template <int dim, int fe_degree>
void GelfandProblem<dim, fe_degree>::local_evaluate_residual(
- const MatrixFree<dim, double> & data,
- LinearAlgebra::distributed::Vector<double> & dst,
+ const MatrixFree<dim, double> &data,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, double> phi(data);
: Function<dim>(dim + 2, time)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
// velocity field, computed from the relation $E = \frac{c^2}{\gamma (\gamma
// -1)} + \frac 12 \rho \|u\|^2$.
template <int dim>
- double ExactSolution<dim>::value(const Point<dim> & x,
+ double ExactSolution<dim>::value(const Point<dim> &x,
const unsigned int component) const
{
const double t = this->get_time();
void perform_time_step(const Operator &pde_operator,
const double current_time,
const double time_step,
- VectorType & solution,
- VectorType & vec_ri,
- VectorType & vec_ki) const
+ VectorType &solution,
+ VectorType &vec_ri,
+ VectorType &vec_ki) const
{
AssertDimension(ai.size() + 1, bi.size());
inline DEAL_II_ALWAYS_INLINE //
Tensor<1, n_components, Number>
operator*(const Tensor<1, n_components, Tensor<1, dim, Number>> &matrix,
- const Tensor<1, dim, Number> & vector)
+ const Tensor<1, dim, Number> &vector)
{
Tensor<1, n_components, Number> result;
for (unsigned int d = 0; d < n_components; ++d)
Tensor<1, dim + 2, Number>
euler_numerical_flux(const Tensor<1, dim + 2, Number> &u_m,
const Tensor<1, dim + 2, Number> &u_p,
- const Tensor<1, dim, Number> & normal)
+ const Tensor<1, dim, Number> &normal)
{
const auto velocity_m = euler_velocity<dim>(u_m);
const auto velocity_p = euler_velocity<dim>(u_p);
// where all components of the solution are set.
template <int dim, typename Number>
VectorizedArray<Number>
- evaluate_function(const Function<dim> & function,
+ evaluate_function(const Function<dim> &function,
const Point<dim, VectorizedArray<Number>> &p_vectorized,
const unsigned int component)
{
template <int dim, typename Number, int n_components = dim + 2>
Tensor<1, n_components, VectorizedArray<Number>>
- evaluate_function(const Function<dim> & function,
+ evaluate_function(const Function<dim> &function,
const Point<dim, VectorizedArray<Number>> &p_vectorized)
{
AssertDimension(function.n_components, n_components);
EulerOperator(TimerOutput &timer_output);
- void reinit(const Mapping<dim> & mapping,
+ void reinit(const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler);
void set_inflow_boundary(const types::boundary_id boundary_id,
void apply(const double current_time,
const LinearAlgebra::distributed::Vector<Number> &src,
- LinearAlgebra::distributed::Vector<Number> & dst) const;
+ LinearAlgebra::distributed::Vector<Number> &dst) const;
void
perform_stage(const Number cur_time,
const Number factor_solution,
const Number factor_ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
- LinearAlgebra::distributed::Vector<Number> & solution,
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &solution,
LinearAlgebra::distributed::Vector<Number> &next_ri) const;
- void project(const Function<dim> & function,
+ void project(const Function<dim> &function,
LinearAlgebra::distributed::Vector<Number> &solution) const;
std::array<double, 3> compute_errors(
- const Function<dim> & function,
+ const Function<dim> &function,
const LinearAlgebra::distributed::Vector<Number> &solution) const;
double compute_cell_transport_speed(
std::unique_ptr<Function<dim>> body_force;
void local_apply_inverse_mass_matrix(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
void local_apply_cell(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
void local_apply_face(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const;
+ const std::pair<unsigned int, unsigned int> &face_range) const;
void local_apply_boundary_face(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const;
+ const std::pair<unsigned int, unsigned int> &face_range) const;
};
// necessary to ensure optimal computational efficiency overall.
template <int dim, int degree, int n_points_1d>
void EulerOperator<dim, degree, n_points_1d>::reinit(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler)
{
const std::vector<const DoFHandler<dim> *> dof_handlers = {&dof_handler};
template <int dim, int degree, int n_points_1d>
void EulerOperator<dim, degree, n_points_1d>::local_apply_cell(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree, n_points_1d, dim + 2, Number> phi(data);
template <int dim, int degree, int n_points_1d>
void EulerOperator<dim, degree, n_points_1d>::local_apply_face(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, degree, n_points_1d, dim + 2, Number> phi_m(data,
true);
template <int dim, int degree, int n_points_1d>
void EulerOperator<dim, degree, n_points_1d>::local_apply_boundary_face(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, degree, n_points_1d, dim + 2, Number> phi(data, true);
template <int dim, int degree, int n_points_1d>
void EulerOperator<dim, degree, n_points_1d>::local_apply_inverse_mass_matrix(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree, degree + 1, dim + 2, Number> phi(data, 0, 1);
MatrixFreeOperators::CellwiseInverseMassMatrix<dim, degree, dim + 2, Number>
void EulerOperator<dim, degree, n_points_1d>::apply(
const double current_time,
const LinearAlgebra::distributed::Vector<Number> &src,
- LinearAlgebra::distributed::Vector<Number> & dst) const
+ LinearAlgebra::distributed::Vector<Number> &dst) const
{
{
TimerOutput::Scope t(timer, "apply - integrals");
const Number factor_solution,
const Number factor_ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
- LinearAlgebra::distributed::Vector<Number> & solution,
- LinearAlgebra::distributed::Vector<Number> & next_ri) const
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &solution,
+ LinearAlgebra::distributed::Vector<Number> &next_ri) const
{
{
TimerOutput::Scope t(timer, "rk_stage - integrals L_h");
// cell for discontinuous Galerkin discretizations.
template <int dim, int degree, int n_points_1d>
void EulerOperator<dim, degree, n_points_1d>::project(
- const Function<dim> & function,
+ const Function<dim> &function,
LinearAlgebra::distributed::Vector<Number> &solution) const
{
FEEvaluation<dim, degree, degree + 1, dim + 2, Number> phi(data, 0, 1);
// has a remainder compared to the SIMD width.
template <int dim, int degree, int n_points_1d>
std::array<double, 3> EulerOperator<dim, degree, n_points_1d>::compute_errors(
- const Function<dim> & function,
+ const Function<dim> &function,
const LinearAlgebra::distributed::Vector<Number> &solution) const
{
TimerOutput::Scope t(timer, "compute errors");
template <int dim>
void EulerProblem<dim>::Postprocessor::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
const unsigned int n_evaluation_points = inputs.solution_values.size();
virtual void vector_value(const Point<dim> &point,
- Vector<double> & values) const override;
+ Vector<double> &values) const override;
};
// simulation (t) must be gathered from the Function object.
template <int dim>
void Vortex<dim>::vector_value(const Point<dim> &point,
- Vector<double> & values) const
+ Vector<double> &values) const
{
const double T = 4;
const double t = this->get_time();
// `private`.
unsigned int cell_weight(
const typename parallel::distributed::Triangulation<dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status) const;
// The following two functions are responsible for outputting the simulation
template <int dim>
unsigned int ParticleTracking<dim>::cell_weight(
const typename parallel::distributed::Triangulation<dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status) const
{
// First, we introduce a base weight that will be assigned to every cell.
{
public:
Discretization(const MPI_Comm mpi_communicator,
- TimerOutput & computing_timer,
+ TimerOutput &computing_timer,
const std::string &subsection = "Discretization");
void setup();
std::tuple<Tensor<1, dim>, types::boundary_id, Point<dim>>>;
OfflineData(const MPI_Comm mpi_communicator,
- TimerOutput & computing_timer,
+ TimerOutput &computing_timer,
const Discretization<dim> &discretization,
- const std::string & subsection = "OfflineData");
+ const std::string &subsection = "OfflineData");
void setup();
void assemble();
private:
const MPI_Comm mpi_communicator;
- TimerOutput & computing_timer;
+ TimerOutput &computing_timer;
SmartPointer<const Discretization<dim>> discretization;
};
static DEAL_II_ALWAYS_INLINE inline flux_type flux(const state_type &U);
static DEAL_II_ALWAYS_INLINE inline double
- compute_lambda_max(const state_type & U_i,
- const state_type & U_j,
+ compute_lambda_max(const state_type &U_i,
+ const state_type &U_j,
const Tensor<1, dim> &n_ij);
};
n_solution_variables>;
TimeStepping(const MPI_Comm mpi_communicator,
- TimerOutput & computing_timer,
- const OfflineData<dim> & offline_data,
+ TimerOutput &computing_timer,
+ const OfflineData<dim> &offline_data,
const InitialValues<dim> &initial_values,
- const std::string & subsection = "TimeStepping");
+ const std::string &subsection = "TimeStepping");
void prepare();
private:
const MPI_Comm mpi_communicator;
- TimerOutput & computing_timer;
+ TimerOutput &computing_timer;
SmartPointer<const OfflineData<dim>> offline_data;
SmartPointer<const InitialValues<dim>> initial_values;
SchlierenPostprocessor(
const MPI_Comm mpi_communicator,
- TimerOutput & computing_timer,
+ TimerOutput &computing_timer,
const OfflineData<dim> &offline_data,
- const std::string & subsection = "SchlierenPostprocessor");
+ const std::string &subsection = "SchlierenPostprocessor");
void prepare();
private:
const MPI_Comm mpi_communicator;
- TimerOutput & computing_timer;
+ TimerOutput &computing_timer;
SmartPointer<const OfflineData<dim>> offline_data;
// ParameterAcceptor::add_parameter().
template <int dim>
Discretization<dim>::Discretization(const MPI_Comm mpi_communicator,
- TimerOutput & computing_timer,
+ TimerOutput &computing_timer,
const std::string &subsection)
: ParameterAcceptor(subsection)
, mpi_communicator(mpi_communicator)
// initialization list.
template <int dim>
OfflineData<dim>::OfflineData(const MPI_Comm mpi_communicator,
- TimerOutput & computing_timer,
+ TimerOutput &computing_timer,
const Discretization<dim> &discretization,
- const std::string & subsection)
+ const std::string &subsection)
: ParameterAcceptor(subsection)
, dof_handler(discretization.triangulation)
, mpi_communicator(mpi_communicator)
template <typename IteratorType>
DEAL_II_ALWAYS_INLINE inline void
- set_entry(SparseMatrix<double> & matrix,
- const IteratorType & it,
+ set_entry(SparseMatrix<double> &matrix,
+ const IteratorType &it,
SparseMatrix<double>::value_type value)
{
SparseMatrix<double>::iterator matrix_iterator(&matrix,
template <std::size_t k, int k2>
DEAL_II_ALWAYS_INLINE inline void
scatter(std::array<LinearAlgebra::distributed::Vector<double>, k> &U,
- const Tensor<1, k2> & tensor,
+ const Tensor<1, k2> &tensor,
const unsigned int i)
{
static_assert(k == k2,
const auto local_assemble_system = //
[&](const typename DoFHandler<dim>::cell_iterator &cell,
- MeshWorker::ScratchData<dim> & scratch,
- CopyData<dim> & copy) {
+ MeshWorker::ScratchData<dim> &scratch,
+ CopyData<dim> ©) {
copy.is_artificial = cell->is_artificial();
if (copy.is_artificial)
return;
template <int dim>
DEAL_II_ALWAYS_INLINE inline std::array<double, 4> riemann_data_from_state(
const typename ProblemDescription<dim>::state_type U,
- const Tensor<1, dim> & n_ij)
+ const Tensor<1, dim> &n_ij)
{
Tensor<1, 3> projected_U;
projected_U[0] = U[0];
template <int dim>
DEAL_II_ALWAYS_INLINE inline double
- ProblemDescription<dim>::compute_lambda_max(const state_type & U_i,
- const state_type & U_j,
+ ProblemDescription<dim>::compute_lambda_max(const state_type &U_i,
+ const state_type &U_j,
const Tensor<1, dim> &n_ij)
{
const auto riemann_data_i = riemann_data_from_state(U_i, n_ij);
template <int dim>
TimeStepping<dim>::TimeStepping(
const MPI_Comm mpi_communicator,
- TimerOutput & computing_timer,
- const OfflineData<dim> & offline_data,
+ TimerOutput &computing_timer,
+ const OfflineData<dim> &offline_data,
const InitialValues<dim> &initial_values,
- const std::string & subsection /*= "TimeStepping"*/)
+ const std::string &subsection /*= "TimeStepping"*/)
: ParameterAcceptor(subsection)
, mpi_communicator(mpi_communicator)
, computing_timer(computing_timer)
template <int dim>
SchlierenPostprocessor<dim>::SchlierenPostprocessor(
const MPI_Comm mpi_communicator,
- TimerOutput & computing_timer,
+ TimerOutput &computing_timer,
const OfflineData<dim> &offline_data,
- const std::string & subsection /*= "SchlierenPostprocessor"*/)
+ const std::string &subsection /*= "SchlierenPostprocessor"*/)
: ParameterAcceptor(subsection)
, mpi_communicator(mpi_communicator)
, computing_timer(computing_timer)
namespace
{
void print_head(ConditionalOStream &pcout,
- const std::string & header,
- const std::string & secondary = "")
+ const std::string &header,
+ const std::string &secondary = "")
{
const auto header_size = header.size();
const auto padded_header = std::string((34 - header_size) / 2, ' ') +
template <int dim>
void MainLoop<dim>::output(const typename MainLoop<dim>::vector_type &U,
- const std::string & name,
+ const std::string &name,
const double t,
const unsigned int cycle)
{
class Solution : public Function<dim>, protected SolutionBase<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
};
class RightHandSide : public Function<dim>, protected SolutionBase<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
// the @p constitutive_parameters, are all the fundamental quantities that
// are required to compute the material response.
virtual void update_internal_data(const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H,
+ const Tensor<1, dim> &H,
const DiscreteTime &time) = 0;
// The next few functions provide the interface to probe the material
// we'll declare that this class will override all of these base class
// methods.
virtual void update_internal_data(const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H,
+ const Tensor<1, dim> &H,
const DiscreteTime &) override;
virtual double get_psi() const override;
void
Magnetoelastic_Constitutive_Law_AD<dim, ADTypeCode>::update_internal_data(
const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H,
+ const Tensor<1, dim> &H,
const DiscreteTime &)
{
Assert(determinant(C) > 0, ExcInternalError());
{
public:
Magnetoviscoelastic_Constitutive_Law_SD(
- const ConstitutiveParameters & constitutive_parameters,
+ const ConstitutiveParameters &constitutive_parameters,
const Differentiation::SD::OptimizerType optimizer_type,
const Differentiation::SD::OptimizationFlags optimization_flags);
// within the `update_internal_data()` function, and cache the results
// for layer extraction.
virtual void update_internal_data(const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H,
+ const Tensor<1, dim> &H,
const DiscreteTime &time) override;
virtual double get_psi() const override;
// The final method of this class will configure the @p optimizer.
Differentiation::SD::types::substitution_map
make_substitution_map(const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H,
+ const Tensor<1, dim> &H,
const double delta_t) const;
void initialize_optimizer();
template <int dim>
Magnetoviscoelastic_Constitutive_Law_SD<dim>::
Magnetoviscoelastic_Constitutive_Law_SD(
- const ConstitutiveParameters & constitutive_parameters,
+ const ConstitutiveParameters &constitutive_parameters,
const Differentiation::SD::OptimizerType optimizer_type,
const Differentiation::SD::OptimizationFlags optimization_flags)
: Coupled_Magnetomechanical_Constitutive_Law_Base<dim>(
Differentiation::SD::types::substitution_map
Magnetoviscoelastic_Constitutive_Law_SD<dim>::make_substitution_map(
const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H,
+ const Tensor<1, dim> &H,
const double delta_t) const
{
return Differentiation::SD::make_substitution_map(
template <int dim>
void Magnetoviscoelastic_Constitutive_Law_SD<dim>::update_internal_data(
const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H,
- const DiscreteTime & time)
+ const Tensor<1, dim> &H,
+ const DiscreteTime &time)
{
// To update the internal history variable, we first need to compute
// a few fundamental quantities, which we've seen before.
const ConstitutiveParameters &constitutive_parameters);
virtual void update_internal_data(const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H,
+ const Tensor<1, dim> &H,
const DiscreteTime &) override;
virtual double get_psi() const override;
template <int dim>
void Magnetoelastic_Constitutive_Law<dim>::update_internal_data(
const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H,
+ const Tensor<1, dim> &H,
const DiscreteTime &)
{
const double det_F = std::sqrt(determinant(C));
const ConstitutiveParameters &constitutive_parameters);
virtual void update_internal_data(const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H,
+ const Tensor<1, dim> &H,
const DiscreteTime &time) override;
virtual double get_psi() const override;
// internal variables, and will be called before we perform any
// detailed calculations.
void set_primary_variables(const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H) const;
+ const Tensor<1, dim> &H) const;
void update_internal_variable(const DiscreteTime &time);
template <int dim>
void Magnetoviscoelastic_Constitutive_Law<dim>::update_internal_data(
const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H,
- const DiscreteTime & time)
+ const Tensor<1, dim> &H,
+ const DiscreteTime &time)
{
// Record the applied deformation state as well as the magnetic load.
// Thereafter, update internal (viscous) variable based on new deformation
// Intermediate quantities. Note that, since we're fetching these values
// from a cache that has a lifetime that outlasts this function call, we
// can alias the result rather than copying the value from the cache.
- const double & det_F = get_det_F();
+ const double &det_F = get_det_F();
const SymmetricTensor<2, dim> &C_inv = get_C_inv();
const double &log_det_F = get_log_det_F();
template <int dim>
void Magnetoviscoelastic_Constitutive_Law<dim>::set_primary_variables(
const SymmetricTensor<2, dim> &C,
- const Tensor<1, dim> & H) const
+ const Tensor<1, dim> &H) const
{
// Set value for $\boldsymbol{\mathbb{H}}$.
const std::string name_H("H");
const std::string name("d2H_dot_C_inv_dot_H_dC_dH");
if (cache.stores_object_with_name(name) == false)
{
- const Tensor<1, dim> & C_inv_dot_H = get_C_inv_dot_H();
+ const Tensor<1, dim> &C_inv_dot_H = get_C_inv_dot_H();
const SymmetricTensor<2, dim> &C_inv = get_C_inv();
Tensor<3, dim> d2H_dot_C_inv_dot_H_dC_dH;
const std::string name("d2H_dot_C_inv_dot_H_dC_dC");
if (cache.stores_object_with_name(name) == false)
{
- const Tensor<1, dim> & C_inv_dot_H = get_C_inv_dot_H();
+ const Tensor<1, dim> &C_inv_dot_H = get_C_inv_dot_H();
const SymmetricTensor<2, dim> &C_inv = get_C_inv();
SymmetricTensor<4, dim> d2H_dot_C_inv_dot_H_dC_dC;
Coupled_Magnetomechanical_Constitutive_Law_Base<dim>
&material_hand_calculated,
Coupled_Magnetomechanical_Constitutive_Law_Base<dim>
- & material_assisted_computation,
- TimerOutput & timer,
+ &material_assisted_computation,
+ TimerOutput &timer,
const std::string &filename)
{
// We can take the hand-implemented constitutive law and compare the
class BoundaryValues : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
// initialize the cell DoF indices, knowing that the local matrix
// and vector are already correctly sized.
const auto cell_worker = [this](const CellIteratorType &cell,
- ScratchData & scratch_data,
- CopyData & copy_data) {
+ ScratchData &scratch_data,
+ CopyData ©_data) {
const auto &fe_values = scratch_data.reinit(cell);
- FullMatrix<double> & cell_matrix = copy_data.matrices[0];
- Vector<double> & cell_rhs = copy_data.vectors[0];
+ FullMatrix<double> &cell_matrix = copy_data.matrices[0];
+ Vector<double> &cell_rhs = copy_data.vectors[0];
std::vector<types::global_dof_index> &local_dof_indices =
copy_data.local_dof_indices[0];
cell->get_dof_indices(local_dof_indices);
// `cell_worker`.
const auto copier = [dofs_per_cell, this](const CopyData ©_data) {
const FullMatrix<double> &cell_matrix = copy_data.matrices[0];
- const Vector<double> & cell_rhs = copy_data.vectors[0];
+ const Vector<double> &cell_rhs = copy_data.vectors[0];
const std::vector<types::global_dof_index> &local_dof_indices =
copy_data.local_dof_indices[0];
// to compute the cell contributions to the Jacobian matrix and
// the right hand side:
const auto cell_worker = [&u_fe, this](const CellIteratorType &cell,
- ScratchData & scratch_data,
- CopyData & copy_data) {
- const auto & fe_values = scratch_data.reinit(cell);
+ ScratchData &scratch_data,
+ CopyData ©_data) {
+ const auto &fe_values = scratch_data.reinit(cell);
const unsigned int dofs_per_cell = fe_values.get_fe().n_dofs_per_cell();
- FullMatrix<double> & cell_matrix = copy_data.matrices[0];
- Vector<double> & cell_rhs = copy_data.vectors[0];
+ FullMatrix<double> &cell_matrix = copy_data.matrices[0];
+ Vector<double> &cell_rhs = copy_data.vectors[0];
std::vector<types::global_dof_index> &local_dof_indices =
copy_data.local_dof_indices[0];
cell->get_dof_indices(local_dof_indices);
// The remainder of the function equals what we had previously:
const auto copier = [dofs_per_cell, this](const CopyData ©_data) {
const FullMatrix<double> &cell_matrix = copy_data.matrices[0];
- const Vector<double> & cell_rhs = copy_data.vectors[0];
+ const Vector<double> &cell_rhs = copy_data.vectors[0];
const std::vector<types::global_dof_index> &local_dof_indices =
copy_data.local_dof_indices[0];
// results from an energy functional is necessarily square (and also,
// incidentally, symmetric).
const auto cell_worker = [&u_fe, this](const CellIteratorType &cell,
- ScratchData & scratch_data,
- CopyData & copy_data) {
+ ScratchData &scratch_data,
+ CopyData ©_data) {
const auto &fe_values = scratch_data.reinit(cell);
- FullMatrix<double> & cell_matrix = copy_data.matrices[0];
- Vector<double> & cell_rhs = copy_data.vectors[0];
+ FullMatrix<double> &cell_matrix = copy_data.matrices[0];
+ Vector<double> &cell_rhs = copy_data.vectors[0];
std::vector<types::global_dof_index> &local_dof_indices =
copy_data.local_dof_indices[0];
cell->get_dof_indices(local_dof_indices);
// before:
const auto copier = [dofs_per_cell, this](const CopyData ©_data) {
const FullMatrix<double> &cell_matrix = copy_data.matrices[0];
- const Vector<double> & cell_rhs = copy_data.vectors[0];
+ const Vector<double> &cell_rhs = copy_data.vectors[0];
const std::vector<types::global_dof_index> &local_dof_indices =
copy_data.local_dof_indices[0];
{}
virtual void value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & point,
+ gradient(const Point<dim> &point,
const unsigned int component = 0) const override;
};
template <int dim>
void SmoothSolution<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const
{
using numbers::PI;
{}
virtual void value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const override;
};
template <int dim>
void
SmoothRightHandSide<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const
{
using numbers::PI;
{}
virtual void value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const override;
private:
template <int dim>
void
SingularRightHandSide<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const
{
for (unsigned int i = 0; i < values.size(); ++i)
const unsigned int dofs_per_cell = fe_v.dofs_per_cell;
copy_data.reinit(cell, dofs_per_cell);
- const auto & q_points = scratch_data.get_quadrature_points();
+ const auto &q_points = scratch_data.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const std::vector<double> &JxW = scratch_data.get_JxW_values();
};
// Next, we need a function that assembles face integrals on the boundary:
- const auto boundary_worker = [&](const auto & cell,
+ const auto boundary_worker = [&](const auto &cell,
const unsigned int &face_no,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEFaceValuesBase<dim> &fe_fv = scratch_data.reinit(cell, face_no);
- const auto & q_points = scratch_data.get_quadrature_points();
+ const auto &q_points = scratch_data.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const unsigned int dofs_per_cell = fe_fv.dofs_per_cell;
- const std::vector<double> & JxW = scratch_data.get_JxW_values();
+ const std::vector<double> &JxW = scratch_data.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals =
scratch_data.get_normal_vectors();
// faces. To reinitialize FEInterfaceValues, we need to pass
// cells, face and subface indices (for adaptive refinement) to
// the reinit() function of FEInterfaceValues:
- const auto face_worker = [&](const auto & cell,
+ const auto face_worker = [&](const auto &cell,
const unsigned int &f,
const unsigned int &sf,
- const auto & ncell,
+ const auto &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEInterfaceValues<dim> &fe_iv =
scratch_data.reinit(cell, f, sf, ncell, nf, nsf);
copy_data.face_data.emplace_back();
- CopyDataFace & copy_data_face = copy_data.face_data.back();
+ CopyDataFace ©_data_face = copy_data.face_data.back();
const unsigned int n_dofs_face = fe_iv.n_current_interface_dofs();
copy_data_face.joint_dof_indices = fe_iv.get_interface_dof_indices();
copy_data_face.cell_matrix.reinit(n_dofs_face, n_dofs_face);
- const std::vector<double> & JxW = fe_iv.get_JxW_values();
+ const std::vector<double> &JxW = fe_iv.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_iv.get_normal_vectors();
const double extent1 = cell->measure() / cell->face(f)->measure();
copy_data.cell_index = cell->active_cell_index();
- const auto & q_points = fe_v.get_quadrature_points();
+ const auto &q_points = fe_v.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const std::vector<double> &JxW = fe_v.get_JxW_values();
// Next compute boundary terms $\sum_{f\in \partial K \cap \partial \Omega}
// \sigma \left\| [ u_h-g_D ] \right\|_f^2 $:
- const auto boundary_worker = [&](const auto & cell,
+ const auto boundary_worker = [&](const auto &cell,
const unsigned int &face_no,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEFaceValuesBase<dim> &fe_fv = scratch_data.reinit(cell, face_no);
- const auto & q_points = fe_fv.get_quadrature_points();
+ const auto &q_points = fe_fv.get_quadrature_points();
const unsigned n_q_points = q_points.size();
const std::vector<double> &JxW = fe_fv.get_JxW_values();
// And finally interior face terms $\sum_{f\in \partial K}\lbrace \sigma
// \left\| [u_h] \right\|_f^2 + h_f \left\| [\nu \nabla u_h \cdot
// \mathbf n ] \right\|_f^2 \rbrace$:
- const auto face_worker = [&](const auto & cell,
+ const auto face_worker = [&](const auto &cell,
const unsigned int &f,
const unsigned int &sf,
- const auto & ncell,
+ const auto &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEInterfaceValues<dim> &fe_iv =
scratch_data.reinit(cell, f, sf, ncell, nf, nsf);
copy_data_face.cell_indices[0] = cell->active_cell_index();
copy_data_face.cell_indices[1] = ncell->active_cell_index();
- const std::vector<double> & JxW = fe_iv.get_JxW_values();
+ const std::vector<double> &JxW = fe_iv.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_iv.get_normal_vectors();
- const auto & q_points = fe_iv.get_quadrature_points();
+ const auto &q_points = fe_iv.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
std::vector<double> jump(n_q_points);
copy_data.cell_index = cell->active_cell_index();
- const auto & q_points = fe_v.get_quadrature_points();
+ const auto &q_points = fe_v.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const std::vector<double> &JxW = fe_v.get_JxW_values();
};
// Assemble $\sum_{f \in F_b}\sigma \|u_h-g_D\|_f^2$.
- const auto boundary_worker = [&](const auto & cell,
+ const auto boundary_worker = [&](const auto &cell,
const unsigned int &face_no,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEFaceValuesBase<dim> &fe_fv = scratch_data.reinit(cell, face_no);
- const auto & q_points = fe_fv.get_quadrature_points();
+ const auto &q_points = fe_fv.get_quadrature_points();
const unsigned n_q_points = q_points.size();
const std::vector<double> &JxW = fe_fv.get_JxW_values();
};
// Assemble $\sum_{f \in F_i} \sigma \| [ u_h ] \|_f^2$.
- const auto face_worker = [&](const auto & cell,
+ const auto face_worker = [&](const auto &cell,
const unsigned int &f,
const unsigned int &sf,
- const auto & ncell,
+ const auto &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEInterfaceValues<dim> &fe_iv =
scratch_data.reinit(cell, f, sf, ncell, nf, nsf);
const std::vector<double> &JxW = fe_iv.get_JxW_values();
- const auto & q_points = fe_iv.get_quadrature_points();
+ const auto &q_points = fe_iv.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
std::vector<double> jump(n_q_points);
LaplaceOperator() = default;
LaplaceOperator(const hp::MappingCollection<dim> &mapping,
- const DoFHandler<dim> & dof_handler,
- const hp::QCollection<dim> & quad,
- const AffineConstraints<number> & constraints,
- VectorType & system_rhs);
+ const DoFHandler<dim> &dof_handler,
+ const hp::QCollection<dim> &quad,
+ const AffineConstraints<number> &constraints,
+ VectorType &system_rhs);
void reinit(const hp::MappingCollection<dim> &mapping,
- const DoFHandler<dim> & dof_handler,
- const hp::QCollection<dim> & quad,
- const AffineConstraints<number> & constraints,
- VectorType & system_rhs);
+ const DoFHandler<dim> &dof_handler,
+ const hp::QCollection<dim> &quad,
+ const AffineConstraints<number> &constraints,
+ VectorType &system_rhs);
types::global_dof_index m() const;
void do_cell_integral_local(FECellIntegrator &integrator) const;
void do_cell_integral_global(FECellIntegrator &integrator,
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const;
void do_cell_integral_range(
- const MatrixFree<dim, number> & matrix_free,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, number> &matrix_free,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &range) const;
MatrixFree<dim, number> matrix_free;
template <int dim, typename number>
LaplaceOperator<dim, number>::LaplaceOperator(
const hp::MappingCollection<dim> &mapping,
- const DoFHandler<dim> & dof_handler,
- const hp::QCollection<dim> & quad,
- const AffineConstraints<number> & constraints,
- VectorType & system_rhs)
+ const DoFHandler<dim> &dof_handler,
+ const hp::QCollection<dim> &quad,
+ const AffineConstraints<number> &constraints,
+ VectorType &system_rhs)
{
this->reinit(mapping, dof_handler, quad, constraints, system_rhs);
}
template <int dim, typename number>
void LaplaceOperator<dim, number>::reinit(
const hp::MappingCollection<dim> &mapping,
- const DoFHandler<dim> & dof_handler,
- const hp::QCollection<dim> & quad,
- const AffineConstraints<number> & constraints,
- VectorType & system_rhs)
+ const DoFHandler<dim> &dof_handler,
+ const hp::QCollection<dim> &quad,
+ const AffineConstraints<number> &constraints,
+ VectorType &system_rhs)
{
// Clear internal data structures (in the case that the operator is reused).
this->system_matrix.clear();
// over all cells and evaluating the effect of the cell integrals (see also:
// `do_cell_integral_local()` and `do_cell_integral_global()`).
template <int dim, typename number>
- void LaplaceOperator<dim, number>::vmult(VectorType & dst,
+ void LaplaceOperator<dim, number>::vmult(VectorType &dst,
const VectorType &src) const
{
this->matrix_free.cell_loop(
// Perform the transposed operator evaluation. Since we are considering
// symmetric "matrices", this function can simply delegate it task to vmult().
template <int dim, typename number>
- void LaplaceOperator<dim, number>::Tvmult(VectorType & dst,
+ void LaplaceOperator<dim, number>::Tvmult(VectorType &dst,
const VectorType &src) const
{
this->vmult(dst, src);
template <int dim, typename number>
void LaplaceOperator<dim, number>::do_cell_integral_global(
FECellIntegrator &integrator,
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
integrator.gather_evaluate(src, EvaluationFlags::gradients);
// calls the above function.
template <int dim, typename number>
void LaplaceOperator<dim, number>::do_cell_integral_range(
- const MatrixFree<dim, number> & matrix_free,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, number> &matrix_free,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &range) const
{
FECellIntegrator integrator(matrix_free, range);
typename LevelMatrixType,
typename MGTransferType>
static void
- mg_solve(SolverControl & solver_control,
- VectorType & dst,
- const VectorType & src,
+ mg_solve(SolverControl &solver_control,
+ VectorType &dst,
+ const VectorType &src,
const MultigridParameters &mg_data,
- const DoFHandler<dim> & dof,
- const SystemMatrixType & fine_matrix,
+ const DoFHandler<dim> &dof,
+ const SystemMatrixType &fine_matrix,
const MGLevelObject<std::unique_ptr<LevelMatrixType>> &mg_matrices,
- const MGTransferType & mg_transfer)
+ const MGTransferType &mg_transfer)
{
AssertThrow(mg_data.coarse_solver.type == "cg_with_amg",
ExcNotImplemented());
// particular the operators, and the transfer operator as a
// MGTransferGlobalCoarsening object.
template <typename VectorType, typename OperatorType, int dim>
- void solve_with_gmg(SolverControl & solver_control,
- const OperatorType & system_matrix,
- VectorType & dst,
- const VectorType & src,
- const MultigridParameters & mg_data,
+ void solve_with_gmg(SolverControl &solver_control,
+ const OperatorType &system_matrix,
+ VectorType &dst,
+ const VectorType &src,
+ const MultigridParameters &mg_data,
const hp::MappingCollection<dim> mapping_collection,
- const DoFHandler<dim> & dof_handler,
- const hp::QCollection<dim> & quadrature_collection)
+ const DoFHandler<dim> &dof_handler,
+ const hp::QCollection<dim> &quadrature_collection)
{
// Create a DoFHandler and operator for each multigrid level,
// as well as, create transfer operators. To be able to
for (unsigned int level = minlevel; level <= maxlevel; ++level)
{
const auto &dof_handler = dof_handlers[level];
- auto & constraint = constraints[level];
+ auto &constraint = constraints[level];
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
void perform_time_step(const Operator &pde_operator,
const double current_time,
const double time_step,
- VectorType & solution,
- VectorType & vec_ri,
- VectorType & vec_ki) const
+ VectorType &solution,
+ VectorType &vec_ri,
+ VectorType &vec_ki) const
{
AssertDimension(ai.size() + 1, bi.size());
: Function<dim>(dim + 2, time)
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
template <int dim>
- double ExactSolution<dim>::value(const Point<dim> & x,
+ double ExactSolution<dim>::value(const Point<dim> &x,
const unsigned int component) const
{
const double t = this->get_time();
inline DEAL_II_ALWAYS_INLINE //
Tensor<1, n_components, Number>
operator*(const Tensor<1, n_components, Tensor<1, dim, Number>> &matrix,
- const Tensor<1, dim, Number> & vector)
+ const Tensor<1, dim, Number> &vector)
{
Tensor<1, n_components, Number> result;
for (unsigned int d = 0; d < n_components; ++d)
Tensor<1, dim + 2, Number>
euler_numerical_flux(const Tensor<1, dim + 2, Number> &u_m,
const Tensor<1, dim + 2, Number> &u_p,
- const Tensor<1, dim, Number> & normal)
+ const Tensor<1, dim, Number> &normal)
{
const auto velocity_m = euler_velocity<dim>(u_m);
const auto velocity_p = euler_velocity<dim>(u_p);
// General-purpose utility functions from step-67:
template <int dim, typename VectorizedArrayType>
VectorizedArrayType
- evaluate_function(const Function<dim> & function,
+ evaluate_function(const Function<dim> &function,
const Point<dim, VectorizedArrayType> &p_vectorized,
const unsigned int component)
{
template <int dim, typename VectorizedArrayType, int n_components = dim + 2>
Tensor<1, n_components, VectorizedArrayType>
- evaluate_function(const Function<dim> & function,
+ evaluate_function(const Function<dim> &function,
const Point<dim, VectorizedArrayType> &p_vectorized)
{
AssertDimension(function.n_components, n_components);
~EulerOperator();
- void reinit(const Mapping<dim> & mapping,
+ void reinit(const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler);
void set_inflow_boundary(const types::boundary_id boundary_id,
const Number bi,
const Number ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
LinearAlgebra::distributed::Vector<Number> &solution) const;
- void project(const Function<dim> & function,
+ void project(const Function<dim> &function,
LinearAlgebra::distributed::Vector<Number> &solution) const;
std::array<double, 3> compute_errors(
- const Function<dim> & function,
+ const Function<dim> &function,
const LinearAlgebra::distributed::Vector<Number> &solution) const;
double compute_cell_transport_speed(
// the MPI-3.0 shared-memory capabilities are used:
template <int dim, int degree, int n_points_1d>
void EulerOperator<dim, degree, n_points_1d>::reinit(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler)
{
const std::vector<const DoFHandler<dim> *> dof_handlers = {&dof_handler};
const Number bi,
const Number ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
- LinearAlgebra::distributed::Vector<Number> & solution) const
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &solution) const
{
for (auto &i : inflow_boundaries)
i.second->set_time(current_time);
template <int dim, int degree, int n_points_1d>
void EulerOperator<dim, degree, n_points_1d>::project(
- const Function<dim> & function,
+ const Function<dim> &function,
LinearAlgebra::distributed::Vector<Number> &solution) const
{
FEEvaluation<dim, degree, degree + 1, dim + 2, Number, VectorizedArrayType>
template <int dim, int degree, int n_points_1d>
std::array<double, 3> EulerOperator<dim, degree, n_points_1d>::compute_errors(
- const Function<dim> & function,
+ const Function<dim> &function,
const LinearAlgebra::distributed::Vector<Number> &solution) const
{
TimerOutput::Scope t(timer, "compute errors");
template <int dim>
void EulerProblem<dim>::Postprocessor::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
const unsigned int n_evaluation_points = inputs.solution_values.size();
private:
void setup_system(const bool initial_step);
void solve(const Vector<double> &rhs,
- Vector<double> & solution,
+ Vector<double> &solution,
const double tolerance);
void refine_mesh();
void output_results(const unsigned int refinement_cycle);
void set_boundary_values();
void compute_and_factorize_jacobian(const Vector<double> &evaluation_point);
void compute_residual(const Vector<double> &evaluation_point,
- Vector<double> & residual);
+ Vector<double> &residual);
Triangulation<dim> triangulation;
class BoundaryValues : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
template <int dim>
void MinimalSurfaceProblem<dim>::compute_residual(
const Vector<double> &evaluation_point,
- Vector<double> & residual)
+ Vector<double> &residual)
{
TimerOutput::Scope t(computing_timer, "assembling the residual");
// only inexactly.
template <int dim>
void MinimalSurfaceProblem<dim>::solve(const Vector<double> &rhs,
- Vector<double> & solution,
+ Vector<double> &solution,
const double /*tolerance*/)
{
TimerOutput::Scope t(computing_timer, "linear system solve");
nonlinear_solver.residual =
[&](const Vector<double> &evaluation_point,
- Vector<double> & residual) {
+ Vector<double> &residual) {
compute_residual(evaluation_point, residual);
};
};
nonlinear_solver.solve_with_jacobian = [&](const Vector<double> &rhs,
- Vector<double> & dst,
+ Vector<double> &dst,
const double tolerance) {
solve(rhs, dst, tolerance);
};
public:
Solution(const double maturity_time);
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
template <int dim>
- double Solution<dim>::value(const Point<dim> & p,
+ double Solution<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
return -Utilities::fixed_power<2, double>(p(component)) -
template <int dim>
- Tensor<1, dim> Solution<dim>::gradient(const Point<dim> & p,
+ Tensor<1, dim> Solution<dim>::gradient(const Point<dim> &p,
const unsigned int component) const
{
return Point<dim>(-2 * p(component));
public:
InitialConditions(const double strike_price);
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
template <int dim>
- double InitialConditions<dim>::value(const Point<dim> & p,
+ double InitialConditions<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
#ifdef MMS
class LeftBoundaryValues : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
public:
RightBoundaryValues(const double strike_price, const double interest_rate);
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
template <int dim>
- double RightBoundaryValues<dim>::value(const Point<dim> & p,
+ double RightBoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
#ifdef MMS
public:
RightHandSide(const double asset_volatility, const double interest_rate);
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
template <int dim>
- double RightHandSide<dim>::value(const Point<dim> & p,
+ double RightHandSide<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
#ifdef MMS
{
if (!(check_cell->face(n)->at_boundary()))
{
- const auto & neighbor = check_cell->neighbor(n);
+ const auto &neighbor = check_cell->neighbor(n);
const double distance =
cell->center().distance(neighbor->center());
if ((distance < filter_r) &&
// just fine in 3d, however.
template <int dim>
void right_hand_side(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & values)
+ std::vector<Tensor<1, dim>> &values)
{
AssertDimension(values.size(), points.size());
Assert(dim >= 2, ExcNotImplemented());
public:
rank2_type epsilon(const Point<dim> &x, types::material_id material);
- std::complex<double> mu_inv(const Point<dim> & x,
+ std::complex<double> mu_inv(const Point<dim> &x,
types::material_id material);
- rank2_type sigma(const Point<dim> & x,
+ rank2_type sigma(const Point<dim> &x,
types::material_id left,
types::material_id right);
template <int dim>
DEAL_II_ALWAYS_INLINE inline Tensor<1, dim, std::complex<double>>
tangential_part(const Tensor<1, dim, std::complex<double>> &tensor,
- const Tensor<1, dim> & normal)
+ const Tensor<1, dim> &normal)
{
auto result = tensor;
result[0] = normal[1] * (tensor[0] * normal[1] - tensor[1] * normal[0]);
// <code>face=cell->face(face_no)</code>.
void assemble_local_matrix(const FEValues<dim> &fe_values_lift,
const unsigned int n_q_points,
- FullMatrix<double> & local_matrix);
+ FullMatrix<double> &local_matrix);
void compute_discrete_hessians(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- std::vector<std::vector<Tensor<2, dim>>> & discrete_hessians,
+ std::vector<std::vector<Tensor<2, dim>>> &discrete_hessians,
std::vector<std::vector<std::vector<Tensor<2, dim>>>>
&discrete_hessians_neigh);
: Function<dim>()
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
: Function<dim>()
{}
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual SymmetricTensor<2, dim>
- hessian(const Point<dim> & p,
+ hessian(const Point<dim> &p,
const unsigned int component = 0) const override;
};
void BiLaplacianLDGLift<dim>::assemble_local_matrix(
const FEValues<dim> &fe_values_lift,
const unsigned int n_q_points,
- FullMatrix<double> & local_matrix)
+ FullMatrix<double> &local_matrix)
{
const FEValuesExtractors::Tensor<2> tau_ext(0);
template <int dim>
void BiLaplacianLDGLift<dim>::compute_discrete_hessians(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- std::vector<std::vector<Tensor<2, dim>>> & discrete_hessians,
+ std::vector<std::vector<Tensor<2, dim>>> &discrete_hessians,
std::vector<std::vector<std::vector<Tensor<2, dim>>>>
&discrete_hessians_neigh)
{
{
std::cout << "Initializing matrices" << std::endl;
- const auto face_has_flux_coupling = [&](const auto & cell,
+ const auto face_has_flux_coupling = [&](const auto &cell,
const unsigned int face_index) {
return this->face_has_ghost_penalty(cell, face_index);
};
class AnalyticalSolution : public Function<dim>
{
public:
- double value(const Point<dim> & point,
+ double value(const Point<dim> &point,
const unsigned int component = 0) const override;
};
template <int dim>
- double AnalyticalSolution<dim>::value(const Point<dim> & point,
+ double AnalyticalSolution<dim>::value(const Point<dim> &point,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
class RightHandSide : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
// one past the last (i.e. again the half-open interval so often used in the
// C++ standard library):
template <int dim>
- double RightHandSide<dim>::value(const Point<dim> & p,
+ double RightHandSide<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
class BoundaryValues : public Function<dim>
{
public:
- virtual double value(const Point<dim> & p,
+ virtual double value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
template <int dim>
- double BoundaryValues<dim>::value(const Point<dim> & p,
+ double BoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
void assemble_system();
void local_assemble_system(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- AssemblyScratchData & scratch,
- AssemblyCopyData & copy_data);
+ AssemblyScratchData &scratch,
+ AssemblyCopyData ©_data);
void copy_local_to_global(const AssemblyCopyData ©_data);
public:
template <int dim>
static void estimate(const DoFHandler<dim> &dof,
- const Vector<double> & solution,
- Vector<float> & error_per_cell);
+ const Vector<double> &solution,
+ Vector<float> &error_per_cell);
DeclException2(ExcInvalidVectorLength,
int,
struct EstimateScratchData
{
EstimateScratchData(const FiniteElement<dim> &fe,
- const Vector<double> & solution,
- Vector<float> & error_per_cell);
+ const Vector<double> &solution,
+ Vector<float> &error_per_cell);
EstimateScratchData(const EstimateScratchData &data);
FEValues<dim> fe_midpoint_value;
active_neighbors;
const Vector<double> &solution;
- Vector<float> & error_per_cell;
+ Vector<float> &error_per_cell;
std::vector<double> cell_midpoint_value;
std::vector<double> neighbor_midpoint_value;
static void
estimate_cell(const typename DoFHandler<dim>::active_cell_iterator &cell,
EstimateScratchData<dim> &scratch_data,
- const EstimateCopyData & copy_data);
+ const EstimateCopyData ©_data);
};
template <int dim>
void AdvectionProblem<dim>::local_assemble_system(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- AssemblyScratchData & scratch_data,
- AssemblyCopyData & copy_data)
+ AssemblyScratchData &scratch_data,
+ AssemblyCopyData ©_data)
{
// We define some abbreviations to avoid unnecessarily long lines:
const unsigned int dofs_per_cell = fe.n_dofs_per_cell();
template <int dim>
GradientEstimation::EstimateScratchData<dim>::EstimateScratchData(
const FiniteElement<dim> &fe,
- const Vector<double> & solution,
- Vector<float> & error_per_cell)
+ const Vector<double> &solution,
+ Vector<float> &error_per_cell)
: fe_midpoint_value(fe,
QMidpoint<dim>(),
update_values | update_quadrature_points)
// well worth the effort to check for such things.
template <int dim>
void GradientEstimation::estimate(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution,
- Vector<float> & error_per_cell)
+ const Vector<double> &solution,
+ Vector<float> &error_per_cell)
{
Assert(
error_per_cell.size() == dof_handler.get_triangulation().n_active_cells(),
template <int dim>
void GradientEstimation::estimate_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- EstimateScratchData<dim> & scratch_data,
+ EstimateScratchData<dim> &scratch_data,
const EstimateCopyData &)
{
// We need space for the tensor <code>Y</code>, which is the sum of
AnyData::entry(const std::string &n)
{
const unsigned int i = find(n);
- type * p = boost::any_cast<type>(&data[i]);
+ type *p = boost::any_cast<type>(&data[i]);
Assert(p != 0, ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
return *p;
}
AnyData::entry(const std::string &n) const
{
const unsigned int i = find(n);
- const type * p = boost::any_cast<type>(&data[i]);
+ const type *p = boost::any_cast<type>(&data[i]);
Assert(p != nullptr,
ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
return *p;
AnyData::read(const std::string &n) const
{
const unsigned int i = find(n);
- const type * p = boost::any_cast<type>(&data[i]);
+ const type *p = boost::any_cast<type>(&data[i]);
Assert(p != 0, ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
return *p;
}
// Compute index and return casted pointer
unsigned int i = it - names.begin();
- const type * p = boost::any_cast<type>(&data[i]);
+ const type *p = boost::any_cast<type>(&data[i]);
return p;
}
template <typename Type, typename Arg, typename... Args>
Type &
get_or_add_object_with_name(const std::string &name,
- Arg & argument,
+ Arg &argument,
Args &...arguments);
/**
template <typename Type, typename Arg, typename... Args>
Type &
get_or_add_object_with_name(const std::string &name,
- Arg && argument,
+ Arg &&argument,
Args &&...arguments);
/**
template <typename Type>
void
GeneralDataStorage::add_or_overwrite_copy(const std::string &name,
- const Type & entry)
+ const Type &entry)
{
any_data[name] = entry;
}
template <typename Type>
void
GeneralDataStorage::add_or_overwrite_reference(const std::string &name,
- Type & entry)
+ Type &entry)
{
Type *ptr = &entry;
any_data[name] = ptr;
template <typename Type, typename Arg>
Type &
GeneralDataStorage::get_or_add_object_with_name(const std::string &name,
- Arg & argument)
+ Arg &argument)
{
if (!stores_object_with_name(name))
add_unique_copy(name, Type(argument));
template <typename Type, typename Arg, typename... Args>
Type &
GeneralDataStorage::get_or_add_object_with_name(const std::string &name,
- Arg & argument,
+ Arg &argument,
Args &...arguments)
{
if (!stores_object_with_name(name))
template <typename Type, typename Arg>
Type &
GeneralDataStorage::get_or_add_object_with_name(const std::string &name,
- Arg && argument)
+ Arg &&argument)
{
if (!stores_object_with_name(name))
add_unique_copy(name, Type(std::forward<Arg>(argument)));
template <typename Type, typename Arg, typename... Args>
Type &
GeneralDataStorage::get_or_add_object_with_name(const std::string &name,
- Arg && argument,
+ Arg &&argument,
Args &&...arguments)
{
if (!stores_object_with_name(name))
LogStream::Prefix prefix("Theta");
- VectorType & solution = *out.entry<VectorType *>(0);
+ VectorType &solution = *out.entry<VectorType *>(0);
GrowingVectorMemory<VectorType> mem;
typename VectorMemory<VectorType>::Pointer aux(mem);
aux->reinit(solution);
*/
Deleter(AlignedVector<T> *owning_object,
const bool is_shmem_root,
- T * aligned_shmem_pointer,
+ T *aligned_shmem_pointer,
MPI_Comm shmem_group_communicator,
MPI_Win shmem_window);
#endif
* identify the MPI window in which the data resides.
*/
MPISharedMemDeleterAction(const bool is_shmem_root,
- T * aligned_shmem_pointer,
+ T *aligned_shmem_pointer,
MPI_Comm shmem_group_communicator,
MPI_Win shmem_window);
* all ancillary information to destroy this window.
*/
const bool is_shmem_root;
- T * aligned_shmem_pointer;
+ T *aligned_shmem_pointer;
MPI_Comm shmem_group_communicator;
MPI_Win shmem_window;
};
* elements, otherwise work in serial.
*/
AlignedVectorInitialize(const std::size_t size,
- const T & element,
+ const T &element,
T *const destination)
: element_(element)
, destination_(destination)
}
private:
- const T & element_;
+ const T &element_;
mutable T *destination_;
bool trivial_element;
template <typename T>
inline AlignedVector<T>::Deleter::Deleter(AlignedVector<T> *owning_object,
const bool is_shmem_root,
- T * aligned_shmem_pointer,
+ T *aligned_shmem_pointer,
MPI_Comm shmem_group_communicator,
MPI_Win shmem_window)
: deleter_action_object(
template <typename T>
inline AlignedVector<T>::Deleter::MPISharedMemDeleterAction::
MPISharedMemDeleterAction(const bool is_shmem_root,
- T * aligned_shmem_pointer,
+ T *aligned_shmem_pointer,
MPI_Comm shmem_group_communicator,
MPI_Win shmem_window)
: is_shmem_root(is_shmem_root)
inline void
AlignedVector<T>::Deleter::MPISharedMemDeleterAction::delete_array(
const AlignedVector<T> *aligned_vector,
- T * ptr)
+ T *ptr)
{
(void)ptr;
// It would be nice to assert that aligned_vector->elements.get() equals ptr,
if (new_size == 0)
clear();
else if (new_size == old_size)
- {} // nothing to do here
+ {
+ } // nothing to do here
else if (new_size < old_size)
{
// call destructor on fields that are released, if the type requires it.
if (new_size == 0)
clear();
else if (new_size == old_size)
- {} // nothing to do here
+ {
+ } // nothing to do here
else if (new_size < old_size)
{
// call destructor on fields that are released, if the type requires it.
if (new_size == 0)
clear();
else if (new_size == old_size)
- {} // nothing to do here
+ {
+ } // nothing to do here
else if (new_size < old_size)
{
// call destructor on fields that are released, if the type requires it.
else if (new_allocated_size == 0)
clear();
else // size_alloc < allocated_size
- {} // nothing to do here
+ {
+ } // nothing to do here
}
// know anything about, and so setting this flag is backward compatible also
// to older MPI versions.
MPI_Win shmem_window;
- void * base_ptr;
+ void *base_ptr;
const MPI_Aint align_by = 64;
const MPI_Aint alloc_size =
Utilities::MPI::broadcast(shmem_group_communicator,
// *think* that the following should do given that we do not use base_ptr and
// available_space any further after the call to std::align.
std::size_t available_space = alloc_size;
- void * base_ptr_backup = base_ptr;
- T * aligned_shmem_pointer = static_cast<T *>(
+ void *base_ptr_backup = base_ptr;
+ T *aligned_shmem_pointer = static_cast<T *>(
std::align(align_by, new_size * sizeof(T), base_ptr, available_space));
Assert(aligned_shmem_pointer != nullptr, ExcInternalError());
AlignedVector<T>::save(Archive &ar, const unsigned int) const
{
size_type vec_size = size();
- ar & vec_size;
+ ar &vec_size;
if (vec_size > 0)
ar &boost::serialization::make_array(elements.get(), vec_size);
}
AlignedVector<T>::load(Archive &ar, const unsigned int)
{
size_type vec_size = 0;
- ar & vec_size;
+ ar &vec_size;
if (vec_size > 0)
{
* In case the container is empty a nullptr is returned.
*/
DEAL_II_HOST_DEVICE value_type *
- data() const noexcept;
+ data() const noexcept;
/**
* Return an iterator pointing to the beginning of the array view.
template <typename ElementType, typename MemorySpaceType>
inline ArrayView<ElementType, MemorySpaceType>::ArrayView(
- value_type * starting_element,
+ value_type *starting_element,
const std::size_t n_elements)
: starting_element(starting_element)
, n_elements(n_elements)
* @relatesalso ArrayView
*/
template <typename ElementType, int N>
-inline ArrayView<ElementType> make_array_view(ElementType (&array)[N])
+inline ArrayView<ElementType>
+make_array_view(ElementType (&array)[N])
{
return ArrayView<ElementType>(array, N);
}
*/
template <typename ElementType>
inline ArrayView<ElementType>
-make_array_view(Table<2, ElementType> & table,
+make_array_view(Table<2, ElementType> &table,
const typename Table<2, ElementType>::size_type row)
{
AssertIndexRange(row, table.size()[0]);
*/
template <typename ElementType>
inline ArrayView<const ElementType>
-make_array_view(const Table<2, ElementType> & table,
+make_array_view(const Table<2, ElementType> &table,
const typename Table<2, ElementType>::size_type row)
{
AssertIndexRange(row, table.size()[0]);
*/
template <typename ElementType>
inline ArrayView<ElementType>
-make_array_view(Table<2, ElementType> & table,
+make_array_view(Table<2, ElementType> &table,
const typename Table<2, ElementType>::size_type row,
const typename Table<2, ElementType>::size_type starting_column,
const std::size_t size_of_view)
*/
template <typename ElementType>
inline ArrayView<const ElementType>
-make_array_view(const Table<2, ElementType> & table,
+make_array_view(const Table<2, ElementType> &table,
const typename Table<2, ElementType>::size_type row,
const typename Table<2, ElementType>::size_type starting_column,
const std::size_t size_of_view)
* #DifferenceFormula.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* #DifferenceFormula.
*/
virtual void
- vector_gradient(const Point<dim> & p,
+ vector_gradient(const Point<dim> &p,
std::vector<Tensor<1, dim>> &gradients) const override;
/**
*/
virtual void
gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int component = 0) const override;
/**
*/
virtual void
vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &gradients) const override;
/**
*/
void
add_datasets(const std::vector<std::vector<double>> &datasets,
- const std::vector<std::string> & dataset_names);
+ const std::vector<std::string> &dataset_names);
protected:
// Copy doc
void
BoundingBoxDataOut<dim>::add_datasets(
const std::vector<std::vector<double>> &datasets,
- const std::vector<std::string> & names)
+ const std::vector<std::string> &names)
{
AssertDimension(datasets.size(), patches.size());
dataset_names = names;
template <typename T>
inline void
copy_to_host(const ArrayView<const T, MemorySpace::CUDA> &in,
- ArrayView<T, MemorySpace::Host> & out)
+ ArrayView<T, MemorySpace::Host> &out)
{
AssertDimension(in.size(), out.size());
cudaError_t cuda_error_code = cudaMemcpy(out.data(),
template <typename T>
inline void
copy_to_dev(const ArrayView<const T, MemorySpace::Host> &in,
- ArrayView<T, MemorySpace::CUDA> & out)
+ ArrayView<T, MemorySpace::CUDA> &out)
{
AssertDimension(in.size(), out.size());
cudaError_t cuda_error_code = cudaMemcpy(out.data(),
/**
* Constructor.
*/
- TecplotFlags(const char * zone_name = nullptr,
+ TecplotFlags(const char *zone_name = nullptr,
const double solution_time = -1.0);
/**
* average/min/max multiple values at a given vertex.
*/
void
- write_data_set(const std::string & name,
+ write_data_set(const std::string &name,
const unsigned int dimension,
const unsigned int set_num,
const Table<2, double> &data_vectors);
void
write_dx(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const DXFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
* Write the given list of patches to the output stream in eps format.
void
write_eps(
const std::vector<Patch<2, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const EpsFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
* This is the same function as above except for domains that are not two-
void
write_eps(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const EpsFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
void
write_gmv(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const GmvFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
* Write the given list of patches to the output stream in gnuplot format.
void
write_gnuplot(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const GnuplotFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
* Write the given list of patches to the output stream for the Povray
void
write_povray(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const PovrayFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
* Write the given list of patches to the output stream in Tecplot ASCII
void
write_tecplot(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const TecplotFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
* Write the given list of patches to the output stream in UCD format
void
write_ucd(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const UcdFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
* Write the given list of patches to the output stream in VTK format. The
void
write_vtk(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const VtkFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
void
write_vtu(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const VtkFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
* This writes the header for the xml based vtu file format. This routine is
void
write_vtu_main(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const VtkFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
* Some visualization programs, such as ParaView, can read several separate
*/
void
write_pvtu_record(
- std::ostream & out,
+ std::ostream &out,
const std::vector<std::string> &piece_names,
const std::vector<std::string> &data_names,
const std::vector<
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const VtkFlags &flags);
/**
*/
void
write_pvd_record(
- std::ostream & out,
+ std::ostream &out,
const std::vector<std::pair<double, std::string>> ×_and_names);
/**
* https://wci.llnl.gov/codes/visit/2.0.0/GettingDataIntoVisIt2.0.0.pdf
*/
void
- write_visit_record(std::ostream & out,
+ write_visit_record(std::ostream &out,
const std::vector<std::string> &piece_names);
/**
* https://wci.llnl.gov/codes/visit/2.0.0/GettingDataIntoVisIt2.0.0.pdf
*/
void
- write_visit_record(std::ostream & out,
+ write_visit_record(std::ostream &out,
const std::vector<std::vector<std::string>> &piece_names);
/**
void
write_svg(
const std::vector<Patch<2, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const SvgFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
* Write the given list of patches to the output stream in deal.II
void
write_deal_II_intermediate(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const Deal_II_IntermediateFlags &flags,
- std::ostream & out);
+ std::ostream &out);
/**
* Like write_deal_II_intermediate() but write all patches from all ranks
void
write_deal_II_intermediate_in_parallel(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const Deal_II_IntermediateFlags &flags,
- const std::string & filename,
+ const std::string &filename,
const MPI_Comm comm,
const CompressionLevel compression);
template <int dim, int spacedim>
void
write_hdf5_parallel(const std::vector<Patch<dim, spacedim>> &patches,
- const DataOutFilter & data_filter,
- const DataOutBase::Hdf5Flags & flags,
- const std::string & filename,
+ const DataOutFilter &data_filter,
+ const DataOutBase::Hdf5Flags &flags,
+ const std::string &filename,
const MPI_Comm comm);
/**
template <int dim, int spacedim>
void
write_hdf5_parallel(const std::vector<Patch<dim, spacedim>> &patches,
- const DataOutFilter & data_filter,
- const DataOutBase::Hdf5Flags & flags,
+ const DataOutFilter &data_filter,
+ const DataOutBase::Hdf5Flags &flags,
const bool write_mesh_file,
- const std::string & mesh_filename,
+ const std::string &mesh_filename,
const std::string &solution_filename,
const MPI_Comm comm);
void
write_filtered_data(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
DataOutFilter &filtered_data);
/**
* by the write_visit_record() function.
*/
void
- write_pvtu_record(std::ostream & out,
+ write_pvtu_record(std::ostream &out,
const std::vector<std::string> &piece_names) const;
/**
*/
void
write_deal_II_intermediate_in_parallel(
- const std::string & filename,
+ const std::string &filename,
const MPI_Comm comm,
const DataOutBase::CompressionLevel compression) const;
*/
XDMFEntry
create_xdmf_entry(const DataOutBase::DataOutFilter &data_filter,
- const std::string & h5_filename,
+ const std::string &h5_filename,
const double cur_time,
const MPI_Comm comm) const;
*/
XDMFEntry
create_xdmf_entry(const DataOutBase::DataOutFilter &data_filter,
- const std::string & h5_mesh_filename,
- const std::string & h5_solution_filename,
+ const std::string &h5_mesh_filename,
+ const std::string &h5_solution_filename,
const double cur_time,
const MPI_Comm comm) const;
*/
void
write_xdmf_file(const std::vector<XDMFEntry> &entries,
- const std::string & filename,
+ const std::string &filename,
const MPI_Comm comm) const;
/**
*/
void
write_hdf5_parallel(const DataOutBase::DataOutFilter &data_filter,
- const std::string & filename,
+ const std::string &filename,
const MPI_Comm comm) const;
/**
void
write_hdf5_parallel(const DataOutBase::DataOutFilter &data_filter,
const bool write_mesh_file,
- const std::string & mesh_filename,
- const std::string & solution_filename,
+ const std::string &mesh_filename,
+ const std::string &solution_filename,
const MPI_Comm comm) const;
/**
* <tt>default_format</tt>.
*/
void
- write(std::ostream & out,
+ write(std::ostream &out,
const DataOutBase::OutputFormat output_format =
DataOutBase::default_format) const;
* cases where <code>solution_filename == mesh_filename</code>, and
* <code>dim==spacedim</code>.
*/
- XDMFEntry(const std::string & filename,
+ XDMFEntry(const std::string &filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
*
* @deprecated Use the constructor that additionally takes a ReferenceCell.
*/
- XDMFEntry(const std::string & filename,
+ XDMFEntry(const std::string &filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
*
* @deprecated Use the constructor that additionally takes a ReferenceCell.
*/
- XDMFEntry(const std::string & mesh_filename,
- const std::string & solution_filename,
+ XDMFEntry(const std::string &mesh_filename,
+ const std::string &solution_filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
* Simplified constructor that calls the complete constructor for
* cases where <code>dim==spacedim</code>.
*/
- XDMFEntry(const std::string & mesh_filename,
- const std::string & solution_filename,
+ XDMFEntry(const std::string &mesh_filename,
+ const std::string &solution_filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
* @deprecated Use the constructor that additionally takes a ReferenceCell.
*/
DEAL_II_DEPRECATED
- XDMFEntry(const std::string & mesh_filename,
- const std::string & solution_filename,
+ XDMFEntry(const std::string &mesh_filename,
+ const std::string &solution_filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
/**
* Constructor that sets all members to provided parameters.
*/
- XDMFEntry(const std::string & mesh_filename,
- const std::string & solution_filename,
+ XDMFEntry(const std::string &mesh_filename,
+ const std::string &solution_filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
template <int spacedim, int dim, typename Number1, typename Number2>
inline Tensor<1, spacedim, typename ProductType<Number1, Number2>::type>
apply_transformation(const DerivativeForm<1, dim, spacedim, Number1> &grad_F,
- const Tensor<1, dim, Number2> & d_x)
+ const Tensor<1, dim, Number2> &d_x)
{
Tensor<1, spacedim, typename ProductType<Number1, Number2>::type> dest;
for (unsigned int i = 0; i < spacedim; ++i)
dim,
typename ProductType<Number1, Number2>::type>
apply_transformation(const DerivativeForm<1, dim, spacedim, Number1> &grad_F,
- const Tensor<2, dim, Number2> & D_X)
+ const Tensor<2, dim, Number2> &D_X)
{
DerivativeForm<1, spacedim, dim, typename ProductType<Number1, Number2>::type>
dest;
template <int dim, typename Number1, typename Number2>
inline Tensor<2, dim, typename ProductType<Number1, Number2>::type>
apply_transformation(const DerivativeForm<1, dim, dim, Number1> &grad_F,
- const Tensor<2, dim, Number2> & D_X)
+ const Tensor<2, dim, Number2> &D_X)
{
Tensor<2, dim, typename ProductType<Number1, Number2>::type> dest;
for (unsigned int i = 0; i < dim; ++i)
n_components,
Tensor<1, spacedim, typename ProductType<Number1, Number2>::type>>
apply_transformation(
- const DerivativeForm<1, dim, spacedim, Number1> & grad_F,
+ const DerivativeForm<1, dim, spacedim, Number1> &grad_F,
const Tensor<1, n_components, Tensor<1, dim, Number2>> &D_X)
{
Tensor<1,
template <typename ExceptionType>
[[noreturn]] void
issue_error_noreturn(ExceptionHandling handling,
- const char * file,
+ const char *file,
int line,
- const char * function,
- const char * cond,
- const char * exc_name,
+ const char *function,
+ const char *cond,
+ const char *exc_name,
ExceptionType e)
{
// Fill the fields of the exception object
*/
template <typename ExceptionType>
void
- issue_error_nothrow(const char * file,
+ issue_error_nothrow(const char *file,
int line,
- const char * function,
- const char * cond,
- const char * exc_name,
+ const char *function,
+ const char *cond,
+ const char *exc_name,
ExceptionType e) noexcept
{
static_assert(std::is_base_of_v<ExceptionBase, ExceptionType>,
* point.
*/
virtual void
- vector_values(const std::vector<Point<dim>> & points,
+ vector_values(const std::vector<Point<dim>> &points,
std::vector<std::vector<double>> &values) const override = 0;
/**
* Gradients in a structure more suitable for vector valued functions. The
*/
virtual void
vector_gradients(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &gradients) const override = 0;
/**
* Force terms in a structure more suitable for vector valued functions.
* as right hand side in Stokes' equations
*/
virtual void
- vector_laplacians(const std::vector<Point<dim>> & points,
+ vector_laplacians(const std::vector<Point<dim>> &points,
std::vector<std::vector<double>> &values) const = 0;
virtual void
vector_value(const Point<dim> &points,
- Vector<double> & value) const override;
+ Vector<double> &value) const override;
virtual double
- value(const Point<dim> & points,
+ value(const Point<dim> &points,
const unsigned int component) const override;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const override;
+ std::vector<Vector<double>> &values) const override;
virtual void
vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &gradients) const override;
/**
* The force term in the momentum equation.
*/
virtual void
vector_laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const override;
+ std::vector<Vector<double>> &values) const override;
/**
* Return an estimate for the memory consumption, in bytes, of this object.
virtual ~PoisseuilleFlow() override = default;
virtual void
- vector_values(const std::vector<Point<dim>> & points,
+ vector_values(const std::vector<Point<dim>> &points,
std::vector<std::vector<double>> &values) const override;
virtual void
vector_gradients(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &gradients) const override;
virtual void
- vector_laplacians(const std::vector<Point<dim>> & points,
+ vector_laplacians(const std::vector<Point<dim>> &points,
std::vector<std::vector<double>> &values) const override;
private:
virtual ~StokesCosine() override = default;
virtual void
- vector_values(const std::vector<Point<dim>> & points,
+ vector_values(const std::vector<Point<dim>> &points,
std::vector<std::vector<double>> &values) const override;
virtual void
vector_gradients(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &gradients) const override;
virtual void
- vector_laplacians(const std::vector<Point<dim>> & points,
+ vector_laplacians(const std::vector<Point<dim>> &points,
std::vector<std::vector<double>> &values) const override;
private:
StokesLSingularity();
virtual void
- vector_values(const std::vector<Point<2>> & points,
+ vector_values(const std::vector<Point<2>> &points,
std::vector<std::vector<double>> &values) const override;
virtual void
vector_gradients(
- const std::vector<Point<2>> & points,
+ const std::vector<Point<2>> &points,
std::vector<std::vector<Tensor<1, 2>>> &gradients) const override;
virtual void
- vector_laplacians(const std::vector<Point<2>> & points,
+ vector_laplacians(const std::vector<Point<2>> &points,
std::vector<std::vector<double>> &values) const override;
private:
virtual ~Kovasznay() override = default;
virtual void
- vector_values(const std::vector<Point<2>> & points,
+ vector_values(const std::vector<Point<2>> &points,
std::vector<std::vector<double>> &values) const override;
virtual void
vector_gradients(
- const std::vector<Point<2>> & points,
+ const std::vector<Point<2>> &points,
std::vector<std::vector<Tensor<1, 2>>> &gradients) const override;
virtual void
- vector_laplacians(const std::vector<Point<2>> & points,
+ vector_laplacians(const std::vector<Point<2>> &points,
std::vector<std::vector<double>> &values) const override;
/// The value of lambda.
*/
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<RangeNumberType> & values,
+ std::vector<RangeNumberType> &values,
const unsigned int component = 0) const;
/**
* separately, to fill the output array.
*/
virtual void
- vector_value_list(const std::vector<Point<dim>> & points,
+ vector_value_list(const std::vector<Point<dim>> &points,
std::vector<Vector<RangeNumberType>> &values) const;
/**
* can be reimplemented in derived classes to speed up performance.
*/
virtual void
- vector_values(const std::vector<Point<dim>> & points,
+ vector_values(const std::vector<Point<dim>> &points,
std::vector<std::vector<RangeNumberType>> &values) const;
/**
*/
virtual void
vector_gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
std::vector<Tensor<1, dim, RangeNumberType>> &gradients) const;
/**
* array.
*/
virtual void
- gradient_list(const std::vector<Point<dim>> & points,
+ gradient_list(const std::vector<Point<dim>> &points,
std::vector<Tensor<1, dim, RangeNumberType>> &gradients,
const unsigned int component = 0) const;
*/
virtual void
vector_gradients(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim, RangeNumberType>>> &gradients) const;
/**
*/
virtual void
vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim, RangeNumberType>>> &gradients) const;
/**
*/
virtual void
laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<RangeNumberType> & values,
+ std::vector<RangeNumberType> &values,
const unsigned int component = 0) const;
/**
* Compute the Laplacians of all components at a set of points.
*/
virtual void
- vector_laplacian_list(const std::vector<Point<dim>> & points,
+ vector_laplacian_list(const std::vector<Point<dim>> &points,
std::vector<Vector<RangeNumberType>> &values) const;
/**
*/
virtual void
vector_hessian(
- const Point<dim> & p,
+ const Point<dim> &p,
std::vector<SymmetricTensor<2, dim, RangeNumberType>> &values) const;
/**
* Compute the Hessian of one component at a set of points.
*/
virtual void
- hessian_list(const std::vector<Point<dim>> & points,
+ hessian_list(const std::vector<Point<dim>> &points,
std::vector<SymmetricTensor<2, dim, RangeNumberType>> &values,
const unsigned int component = 0) const;
*/
virtual void
vector_hessian_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<SymmetricTensor<2, dim, RangeNumberType>>> &values)
const;
value(const Point<dim> &p, const unsigned int component = 0) const override;
virtual void
- vector_value(const Point<dim> & p,
+ vector_value(const Point<dim> &p,
Vector<RangeNumberType> &return_value) const override;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<RangeNumberType> & return_values,
+ std::vector<RangeNumberType> &return_values,
const unsigned int component = 0) const override;
virtual void
vector_value_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Vector<RangeNumberType>> &return_values) const override;
virtual Tensor<1, dim, RangeNumberType>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void
vector_gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
std::vector<Tensor<1, dim, RangeNumberType>> &gradients) const override;
virtual void
- gradient_list(const std::vector<Point<dim>> & points,
+ gradient_list(const std::vector<Point<dim>> &points,
std::vector<Tensor<1, dim, RangeNumberType>> &gradients,
const unsigned int component = 0) const override;
virtual void
vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim, RangeNumberType>>> &gradients)
const override;
virtual SymmetricTensor<2, dim, RangeNumberType>
- hessian(const Point<dim> & point,
+ hessian(const Point<dim> &point,
const unsigned int component = 0) const override;
virtual RangeNumberType
- laplacian(const Point<dim> & point,
+ laplacian(const Point<dim> &point,
const unsigned int component = 0) const override;
virtual std::size_t
* @copydoc Function::gradient()
*/
virtual Tensor<1, dim, RangeNumberType>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* @copydoc Function::laplacian()
*/
virtual RangeNumberType
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* @copydoc Function::hessian()
*/
virtual SymmetricTensor<2, dim, RangeNumberType>
- hessian(const Point<dim> & p,
+ hessian(const Point<dim> &p,
const unsigned int component = 0) const override;
};
} // namespace Functions
* Return the value of the function at the given point for all components.
*/
virtual void
- vector_value(const Point<dim> & p,
+ vector_value(const Point<dim> &p,
Vector<RangeNumberType> &return_value) const override;
/**
*/
virtual void
vector_value_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Vector<RangeNumberType>> &values) const override;
/**
* <tt>values</tt> shall have the right size beforehand, i.e. #n_components.
*/
virtual void
- vector_value(const Point<dim> & p,
+ vector_value(const Point<dim> &p,
Vector<RangeNumberType> &values) const override;
private:
*/
explicit FunctionFromFunctionObjects(
const std::vector<std::function<RangeNumberType(const Point<dim> &)>>
- & values,
+ &values,
const double initial_time = 0.0);
/**
&values,
const std::vector<
std::function<Tensor<1, dim, RangeNumberType>(const Point<dim> &)>>
- & gradients,
+ &gradients,
const double initial_time = 0.0);
* component.
*/
virtual Tensor<1, dim, RangeNumberType>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* <tt>values</tt> shall have the right size beforehand, i.e. #n_components.
*/
virtual void
- vector_value(const Point<dim> & p,
+ vector_value(const Point<dim> &p,
Vector<RangeNumberType> &values) const override;
/**
*/
virtual void
vector_value_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Vector<RangeNumberType>> &value_list) const override;
/**
* point.
*/
virtual Tensor<1, dim, RangeNumberType>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
*/
virtual void
vector_gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
std::vector<Tensor<1, dim, RangeNumberType>> &gradients) const override;
/**
* array.
*/
virtual void
- gradient_list(const std::vector<Point<dim>> & points,
+ gradient_list(const std::vector<Point<dim>> &points,
std::vector<Tensor<1, dim, RangeNumberType>> &gradients,
const unsigned int component = 0) const override;
template <int dim, typename RangeNumberType>
void
-Function<dim, RangeNumberType>::vector_value(const Point<dim> & p,
+Function<dim, RangeNumberType>::vector_value(const Point<dim> &p,
Vector<RangeNumberType> &v) const
{
AssertDimension(v.size(), this->n_components);
void
Function<dim, RangeNumberType>::value_list(
const std::vector<Point<dim>> &points,
- std::vector<RangeNumberType> & values,
+ std::vector<RangeNumberType> &values,
const unsigned int component) const
{
// check whether component is in the valid range is up to the derived
template <int dim, typename RangeNumberType>
void
Function<dim, RangeNumberType>::vector_value_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Vector<RangeNumberType>> &values) const
{
// check whether component is in the valid range is up to the derived
template <int dim, typename RangeNumberType>
void
Function<dim, RangeNumberType>::vector_values(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<RangeNumberType>> &values) const
{
const unsigned int n = this->n_components;
template <int dim, typename RangeNumberType>
void
Function<dim, RangeNumberType>::vector_gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
std::vector<Tensor<1, dim, RangeNumberType>> &v) const
{
AssertDimension(v.size(), this->n_components);
template <int dim, typename RangeNumberType>
void
Function<dim, RangeNumberType>::gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Tensor<1, dim, RangeNumberType>> &gradients,
const unsigned int component) const
{
template <int dim, typename RangeNumberType>
void
Function<dim, RangeNumberType>::vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim, RangeNumberType>>> &gradients) const
{
Assert(gradients.size() == points.size(),
template <int dim, typename RangeNumberType>
void
Function<dim, RangeNumberType>::vector_gradients(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim, RangeNumberType>>> &values) const
{
const unsigned int n = this->n_components;
void
Function<dim, RangeNumberType>::laplacian_list(
const std::vector<Point<dim>> &points,
- std::vector<RangeNumberType> & laplacians,
+ std::vector<RangeNumberType> &laplacians,
const unsigned int component) const
{
// check whether component is in the valid range is up to the derived
template <int dim, typename RangeNumberType>
void
Function<dim, RangeNumberType>::vector_laplacian_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Vector<RangeNumberType>> &laplacians) const
{
// check whether component is in the valid range is up to the derived
template <int dim, typename RangeNumberType>
void
Function<dim, RangeNumberType>::vector_hessian(
- const Point<dim> & p,
+ const Point<dim> &p,
std::vector<SymmetricTensor<2, dim, RangeNumberType>> &v) const
{
AssertDimension(v.size(), this->n_components);
template <int dim, typename RangeNumberType>
void
Function<dim, RangeNumberType>::hessian_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<SymmetricTensor<2, dim, RangeNumberType>> &hessians,
const unsigned int component) const
{
template <int dim, typename RangeNumberType>
void
Function<dim, RangeNumberType>::vector_hessian_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<SymmetricTensor<2, dim, RangeNumberType>>> &hessians)
const
{
void
ConstantFunction<dim, RangeNumberType>::value_list(
const std::vector<Point<dim>> &points,
- std::vector<RangeNumberType> & return_values,
+ std::vector<RangeNumberType> &return_values,
const unsigned int component) const
{
// To avoid warning of unused parameter
template <int dim, typename RangeNumberType>
void
ConstantFunction<dim, RangeNumberType>::vector_value_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Vector<RangeNumberType>> &return_values) const
{
Assert(return_values.size() == points.size(),
template <int dim, typename RangeNumberType>
void
ConstantFunction<dim, RangeNumberType>::gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Tensor<1, dim, RangeNumberType>> &gradients,
const unsigned int /*component*/) const
{
template <int dim, typename RangeNumberType>
void
ConstantFunction<dim, RangeNumberType>::vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim, RangeNumberType>>> &gradients) const
{
Assert(gradients.size() == points.size(),
template <int dim, typename RangeNumberType>
RangeNumberType
IdentityFunction<dim, RangeNumberType>::value(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim, typename RangeNumberType>
void
ComponentSelectFunction<dim, RangeNumberType>::vector_value_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Vector<RangeNumberType>> &values) const
{
Assert(values.size() == points.size(),
template <int dim, typename RangeNumberType>
RangeNumberType
ScalarFunctionFromFunctionObject<dim, RangeNumberType>::value(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim, typename RangeNumberType>
RangeNumberType
VectorFunctionFromScalarFunctionObject<dim, RangeNumberType>::value(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim, typename RangeNumberType>
void
VectorFunctionFromScalarFunctionObject<dim, RangeNumberType>::vector_value(
- const Point<dim> & p,
+ const Point<dim> &p,
Vector<RangeNumberType> &values) const
{
AssertDimension(values.size(), this->n_components);
template <int dim, typename RangeNumberType>
inline RangeNumberType
VectorFunctionFromTensorFunction<dim, RangeNumberType>::value(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim, typename RangeNumberType>
inline void
VectorFunctionFromTensorFunction<dim, RangeNumberType>::vector_value(
- const Point<dim> & p,
+ const Point<dim> &p,
Vector<RangeNumberType> &values) const
{
Assert(values.size() == this->n_components,
template <int dim, typename RangeNumberType>
void
VectorFunctionFromTensorFunction<dim, RangeNumberType>::vector_value_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Vector<RangeNumberType>> &value_list) const
{
Assert(value_list.size() == points.size(),
template <int dim, typename RangeNumberType>
inline Tensor<1, dim, RangeNumberType>
VectorFunctionFromTensorFunction<dim, RangeNumberType>::gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim, typename RangeNumberType>
void
VectorFunctionFromTensorFunction<dim, RangeNumberType>::vector_gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
std::vector<Tensor<1, dim, RangeNumberType>> &gradients) const
{
AssertDimension(gradients.size(), this->n_components);
template <int dim, typename RangeNumberType>
void
VectorFunctionFromTensorFunction<dim, RangeNumberType>::gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Tensor<1, dim, RangeNumberType>> &gradients,
const unsigned int component) const
{
template <int dim, typename RangeNumberType>
void
VectorFunctionFromTensorFunction<dim, RangeNumberType>::vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim, RangeNumberType>>> &gradients) const
{
Assert(gradients.size() == points.size(),
template <int dim, typename RangeNumberType>
void
VectorFunctionFromTensorFunction<dim, RangeNumberType>::vector_gradients(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim, RangeNumberType>>> &gradients) const
{
const unsigned int n = this->n_components;
const std::vector<std::function<RangeNumberType(const Point<dim> &)>> &values,
const std::vector<
std::function<Tensor<1, dim, RangeNumberType>(const Point<dim> &)>>
- & gradients,
+ &gradients,
const double initial_time)
: Function<dim, RangeNumberType>(values.size(), initial_time)
, function_values(values)
template <int dim, typename RangeNumberType>
RangeNumberType
FunctionFromFunctionObjects<dim, RangeNumberType>::value(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim, typename RangeNumberType>
Tensor<1, dim, RangeNumberType>
FunctionFromFunctionObjects<dim, RangeNumberType>::gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
const Point<dim> center = Point<dim>());
virtual double
- value(const Point<dim> & points,
+ value(const Point<dim> &points,
const unsigned int component = 0) const override;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void
gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int component = 0) const override;
private:
const std::vector<double> &interpolation_values);
virtual double
- value(const Point<dim> & point,
+ value(const Point<dim> &point,
const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual SymmetricTensor<2, dim>
- hessian(const Point<dim> & p,
+ hessian(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* the difference formula.
*/
FunctionDerivative(const Function<dim> &f,
- const Point<dim> & direction,
+ const Point<dim> &direction,
const double h = 1.e-6);
/**
* The number of quadrature point must still be the same, when values are
* accessed.
*/
- FunctionDerivative(const Function<dim> & f,
+ FunctionDerivative(const Function<dim> &f,
const std::vector<Point<dim>> &direction,
const double h = 1.e-6);
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
/**
vector_value(const Point<dim> &p, Vector<double> &values) const override;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void
- vector_gradient(const Point<dim> & p,
+ vector_gradient(const Point<dim> &p,
std::vector<Tensor<1, dim>> &gradient) const override;
virtual void
gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int component = 0) const override;
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void
laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const override;
+ std::vector<Vector<double>> &values) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void
gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int component = 0) const override;
virtual void
* Laplacian of the function at one point.
*/
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
*/
virtual void
laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
*/
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
/**
* Gradient at a single point.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
*/
virtual void
gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int component = 0) const override;
/**
* Laplacian at a single point.
*/
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
*/
virtual void
laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
private:
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const override;
+ std::vector<Vector<double>> &values) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void
gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int component = 0) const override;
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void
laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
/**
* Second derivatives at a single point.
*/
virtual SymmetricTensor<2, dim>
- hessian(const Point<dim> & p,
+ hessian(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* Second derivatives at multiple points.
*/
virtual void
- hessian_list(const std::vector<Point<dim>> & points,
+ hessian_list(const std::vector<Point<dim>> &points,
std::vector<SymmetricTensor<2, dim>> &hessians,
const unsigned int component = 0) const override;
};
vector_value(const Point<dim> &p, Vector<double> &values) const override;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const override;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const override;
+ std::vector<Vector<double>> &values) const override;
virtual Tensor<1, dim>
gradient(const Point<dim> &p, const unsigned int component) const override;
virtual void
gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int component) const override;
virtual void
vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &gradients) const override;
virtual double
*/
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
/**
* Gradient at a single point.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
*/
virtual void
gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int component = 0) const override;
/**
* Laplacian at a single point.
*/
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
*/
virtual void
laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
virtual void
value_list(const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
virtual void
std::vector<Vector<double>> &values) const override;
virtual Tensor<1, 2>
- gradient(const Point<2> & p,
+ gradient(const Point<2> &p,
const unsigned int component = 0) const override;
virtual void
gradient_list(const std::vector<Point<2>> &points,
- std::vector<Tensor<1, 2>> & gradients,
+ std::vector<Tensor<1, 2>> &gradients,
const unsigned int component = 0) const override;
virtual void
std::vector<std::vector<Tensor<1, 2>>> &) const override;
virtual double
- laplacian(const Point<2> & p,
+ laplacian(const Point<2> &p,
const unsigned int component = 0) const override;
virtual void
laplacian_list(const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
virtual void
value_list(const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const override;
virtual void
virtual void
gradient_list(const std::vector<Point<2>> &points,
- std::vector<Tensor<1, 2>> & gradients,
+ std::vector<Tensor<1, 2>> &gradients,
const unsigned int component) const override;
virtual void
virtual void
laplacian_list(const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const override;
};
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const override;
+ std::vector<Vector<double>> &values) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void
gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int component = 0) const override;
virtual void
std::vector<std::vector<Tensor<1, dim>>> &) const override;
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
virtual void
laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
virtual void
value_list(const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
virtual void
std::vector<Vector<double>> &values) const override;
virtual Tensor<1, 2>
- gradient(const Point<2> & p,
+ gradient(const Point<2> &p,
const unsigned int component = 0) const override;
virtual void
gradient_list(const std::vector<Point<2>> &points,
- std::vector<Tensor<1, 2>> & gradients,
+ std::vector<Tensor<1, 2>> &gradients,
const unsigned int component = 0) const override;
virtual void
std::vector<std::vector<Tensor<1, 2>>> &) const override;
virtual double
- laplacian(const Point<2> & p,
+ laplacian(const Point<2> &p,
const unsigned int component = 0) const override;
virtual void
laplacian_list(const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
*/
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
/**
* Gradient at one point.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
*/
virtual void
gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int component = 0) const override;
/**
* Laplacian of the function at one point.
*/
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
*/
virtual void
laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
/**
* given point.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* Compute the Laplacian of a given component at point <tt>p</tt>.
*/
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
* given point.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* Compute the Laplacian of a given component at point <tt>p</tt>.
*/
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
* argument.
*/
FourierSineSum(const std::vector<Point<dim>> &fourier_coefficients,
- const std::vector<double> & weights);
+ const std::vector<double> &weights);
/**
* Return the value of the function at the given point. Unless there is
* given point.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* Compute the Laplacian of a given component at point <tt>p</tt>.
*/
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
* argument.
*/
FourierCosineSum(const std::vector<Point<dim>> &fourier_coefficients,
- const std::vector<double> & weights);
+ const std::vector<double> &weights);
/**
* Return the value of the function at the given point. Unless there is
* given point.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* Compute the Laplacian of a given component at point <tt>p</tt>.
*/
virtual double
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
*/
CutOffFunctionTensorProduct(
double radius = 1.0,
- const Point<dim> & center = Point<dim>(),
+ const Point<dim> ¢er = Point<dim>(),
const unsigned int n_components = 1,
const unsigned int select = CutOffFunctionBase<dim>::no_component,
const bool integrate_to_one = false);
* Function gradient at one point.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
*/
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
/**
*/
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const override;
+ std::vector<Vector<double>> &values) const override;
};
*/
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
/**
*/
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const override;
+ std::vector<Vector<double>> &values) const override;
};
*/
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
/**
*/
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const override;
+ std::vector<Vector<double>> &values) const override;
/**
* Function gradient at one point.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
};
*/
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
/**
*/
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const override;
+ std::vector<Vector<double>> &values) const override;
/**
* Function gradient at one point.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
};
*/
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<Number> & values,
+ std::vector<Number> &values,
const unsigned int component = 0) const override;
/**
* Function gradient at one point.
*/
virtual Tensor<1, dim, Number>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
*/
InterpolatedTensorProductGridData(
const std::array<std::vector<double>, dim> &coordinate_values,
- const Table<dim, double> & data_values);
+ const Table<dim, double> &data_values);
/**
* Like the previous constructor, but take the arguments as rvalue
*/
InterpolatedTensorProductGridData(
std::array<std::vector<double>, dim> &&coordinate_values,
- Table<dim, double> && data_values);
+ Table<dim, double> &&data_values);
/**
* Compute the value of the function set by bilinear interpolation of the
* is extended by a constant and so its gradient is extended by 0.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
*/
InterpolatedUniformGridData(
const std::array<std::pair<double, double>, dim> &interval_endpoints,
- const std::array<unsigned int, dim> & n_subintervals,
- const Table<dim, double> & data_values);
+ const std::array<unsigned int, dim> &n_subintervals,
+ const Table<dim, double> &data_values);
/**
* Like the previous constructor, but take the arguments as rvalue
*/
InterpolatedUniformGridData(
std::array<std::pair<double, double>, dim> &&interval_endpoints,
- std::array<unsigned int, dim> && n_subintervals,
- Table<dim, double> && data_values);
+ std::array<unsigned int, dim> &&n_subintervals,
+ Table<dim, double> &&data_values);
/**
* Compute the value of the function set by bilinear interpolation of the
* by a constant whose gradient is then of course zero.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* x_{d}^{\alpha_{i,d}}$. The i-th element of the coefficients vector
* contains the coefficient $a_{i}$ for the i-th monomial.
*/
- Polynomial(const Table<2, double> & exponents,
+ Polynomial(const Table<2, double> &exponents,
const std::vector<double> &coefficients);
/**
*/
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
/**
* Function gradient at one point.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* do not consider time.
*/
virtual void
- initialize(const std::string & vars,
+ initialize(const std::string &vars,
const std::vector<std::string> &expressions,
- const ConstMap & constants,
+ const ConstMap &constants,
const bool time_dependent = false) override;
/**
void
initialize(const std::string &vars,
const std::string &expression,
- const ConstMap & constants,
+ const ConstMap &constants,
const bool time_dependent = false);
/**
value(const Point<dim> &point, const unsigned int component) const override;
Tensor<1, dim>
- gradient(const Point<dim> & point,
+ gradient(const Point<dim> &point,
const unsigned int component) const override;
SymmetricTensor<2, dim>
- hessian(const Point<dim> & point,
+ hessian(const Point<dim> &point,
const unsigned int component) const override;
private:
*/
PointRestriction(const Function<dim + 1> &function,
const unsigned int open_direction,
- const Point<dim> & point);
+ const Point<dim> &point);
double
value(const Point<1> &point, const unsigned int component) const override;
Tensor<1, 1>
- gradient(const Point<1> & point,
+ gradient(const Point<1> &point,
const unsigned int component) const override;
SymmetricTensor<2, 1>
*/
template <int dim>
Point<dim + 1>
- create_higher_dim_point(const Point<dim> & point,
+ create_higher_dim_point(const Point<dim> &point,
const unsigned int component_in_dim_plus_1,
const double coordinate_value);
} // namespace internal
Sphere(const Point<dim> ¢er = Point<dim>(), const double radius = 1);
double
- value(const Point<dim> & point,
+ value(const Point<dim> &point,
const unsigned int component = 0) const override;
/**
* singularity.
*/
Tensor<1, dim>
- gradient(const Point<dim> & point,
+ gradient(const Point<dim> &point,
const unsigned int component = 0) const override;
/**
* singularity.
*/
SymmetricTensor<2, dim>
- hessian(const Point<dim> & point,
+ hessian(const Point<dim> &point,
const unsigned int component = 0) const override;
private:
Plane(const Point<dim> &point, const Tensor<1, dim> &normal);
double
- value(const Point<dim> & point,
+ value(const Point<dim> &point,
const unsigned int component = 0) const override;
Tensor<1, dim>
* @param tolerance Tolerance of the distance computation.
* @param max_iter Max. number of iteration of the distance computation algorithm.
*/
- Ellipsoid(const Point<dim> & center,
+ Ellipsoid(const Point<dim> ¢er,
const std::array<double, dim> &radii,
const double tolerance = 1e-14,
const unsigned int max_iter = 10);
double
- value(const Point<dim> & point,
+ value(const Point<dim> &point,
const unsigned int component = 0) const override;
/**
* rectangle.
*/
double
- value(const Point<dim> & p,
+ value(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
* disk.
*/
double
- value(const Point<dim> & p,
+ value(const Point<dim> &p,
const unsigned int component = 0) const override;
private:
* quantities -- not as the components of a vector that will be
* re-interpreted in a different coordinate system.
*/
- Spherical(const Point<dim> & center = Point<dim>(),
+ Spherical(const Point<dim> ¢er = Point<dim>(),
const unsigned int n_components = 1);
/**
* calls svalue() with it, and returns the result.
*/
virtual double
- value(const Point<dim> & point,
+ value(const Point<dim> &point,
const unsigned int component = 0) const override;
/**
* coordinates.
*/
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
* Cartesian coordinates.
*/
virtual SymmetricTensor<2, dim>
- hessian(const Point<dim> & p,
+ hessian(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
template <int dim>
void
taylor_estimate_function_bounds(
- const Function<dim> & function,
- const BoundingBox<dim> & box,
- std::pair<double, double> & value_bounds,
+ const Function<dim> &function,
+ const BoundingBox<dim> &box,
+ std::pair<double, double> &value_bounds,
std::array<std::pair<double, double>, dim> &gradient_bounds,
const unsigned int component = 0);
* additional argument, defaulting to isotropic refinement of the face.
*/
static unsigned int
- child_cell_on_face(const RefinementCase<dim> & ref_case,
+ child_cell_on_face(const RefinementCase<dim> &ref_case,
const unsigned int face,
const unsigned int subface,
const bool face_orientation = true,
* depends on the number of the child.
*/
static Point<dim>
- cell_to_child_coordinates(const Point<dim> & p,
+ cell_to_child_coordinates(const Point<dim> &p,
const unsigned int child_index,
const RefinementCase<dim> refine_case =
RefinementCase<dim>::isotropic_refinement);
* mother cell.
*/
static Point<dim>
- child_to_cell_coordinates(const Point<dim> & p,
+ child_to_cell_coordinates(const Point<dim> &p,
const unsigned int child_index,
const RefinementCase<dim> refine_case =
RefinementCase<dim>::isotropic_refinement);
template <>
Tensor<1, 1>
-GeometryInfo<1>::d_linear_shape_function_gradient(const Point<1> & xi,
+GeometryInfo<1>::d_linear_shape_function_gradient(const Point<1> &xi,
const unsigned int i);
template <>
Tensor<1, 2>
-GeometryInfo<2>::d_linear_shape_function_gradient(const Point<2> & xi,
+GeometryInfo<2>::d_linear_shape_function_gradient(const Point<2> &xi,
const unsigned int i);
template <>
Tensor<1, 3>
-GeometryInfo<3>::d_linear_shape_function_gradient(const Point<3> & xi,
+GeometryInfo<3>::d_linear_shape_function_gradient(const Point<3> &xi,
const unsigned int i);
// serialization can't deal with bitfields, so copy from/to a full sized
// std::uint8_t
std::uint8_t uchar_value = value;
- ar & uchar_value;
+ ar &uchar_value;
value = uchar_value;
}
template <>
inline Point<1>
-GeometryInfo<1>::cell_to_child_coordinates(const Point<1> & p,
+GeometryInfo<1>::cell_to_child_coordinates(const Point<1> &p,
const unsigned int child_index,
const RefinementCase<1> refine_case)
template <>
inline Point<2>
-GeometryInfo<2>::cell_to_child_coordinates(const Point<2> & p,
+GeometryInfo<2>::cell_to_child_coordinates(const Point<2> &p,
const unsigned int child_index,
const RefinementCase<2> refine_case)
template <>
inline Point<3>
-GeometryInfo<3>::cell_to_child_coordinates(const Point<3> & p,
+GeometryInfo<3>::cell_to_child_coordinates(const Point<3> &p,
const unsigned int child_index,
const RefinementCase<3> refine_case)
template <>
inline Point<1>
-GeometryInfo<1>::child_to_cell_coordinates(const Point<1> & p,
+GeometryInfo<1>::child_to_cell_coordinates(const Point<1> &p,
const unsigned int child_index,
const RefinementCase<1> refine_case)
template <>
inline Point<3>
-GeometryInfo<3>::child_to_cell_coordinates(const Point<3> & p,
+GeometryInfo<3>::child_to_cell_coordinates(const Point<3> &p,
const unsigned int child_index,
const RefinementCase<3> refine_case)
template <>
inline Point<2>
-GeometryInfo<2>::child_to_cell_coordinates(const Point<2> & p,
+GeometryInfo<2>::child_to_cell_coordinates(const Point<2> &p,
const unsigned int child_index,
const RefinementCase<2> refine_case)
{
template <int dim>
inline double
-GeometryInfo<dim>::d_linear_shape_function(const Point<dim> & xi,
+GeometryInfo<dim>::d_linear_shape_function(const Point<dim> &xi,
const unsigned int i)
{
AssertIndexRange(i, GeometryInfo<dim>::vertices_per_cell);
template <>
Tensor<1, 2> inline GeometryInfo<2>::d_linear_shape_function_gradient(
- const Point<2> & xi,
+ const Point<2> &xi,
const unsigned int i)
{
AssertIndexRange(i, GeometryInfo<2>::vertices_per_cell);
template <>
Tensor<1, 3> inline GeometryInfo<3>::d_linear_shape_function_gradient(
- const Point<3> & xi,
+ const Point<3> &xi,
const unsigned int i)
{
AssertIndexRange(i, GeometryInfo<3>::vertices_per_cell);
template <typename Iterator>
std::vector<std::vector<Iterator>>
create_partitioning(
- const Iterator & begin,
+ const Iterator &begin,
const std_cxx20::type_identity_t<Iterator> &end,
const std::function<std::vector<types::global_dof_index>(
- const Iterator &)> & get_conflict_indices)
+ const Iterator &)> &get_conflict_indices)
{
// Number of iterators.
unsigned int n_iterators = 0;
template <typename Iterator>
void
make_dsatur_coloring(
- std::vector<Iterator> & partition,
+ std::vector<Iterator> &partition,
const std::function<std::vector<types::global_dof_index>(
- const Iterator &)> & get_conflict_indices,
+ const Iterator &)> &get_conflict_indices,
std::vector<std::vector<Iterator>> &partition_coloring)
{
partition_coloring.clear();
template <typename Iterator>
std::vector<std::vector<Iterator>>
make_graph_coloring(
- const Iterator & begin,
- const std_cxx20::type_identity_t<Iterator> & end,
+ const Iterator &begin,
+ const std_cxx20::type_identity_t<Iterator> &end,
const std::function<std::vector<types::global_dof_index>(
const std_cxx20::type_identity_t<Iterator> &)> &get_conflict_indices)
{
* For further details, refer to SparsityTools::color_sparsity_pattern.
*/
unsigned int
- color_sparsity_pattern(const SparsityPattern & sparsity_pattern,
+ color_sparsity_pattern(const SparsityPattern &sparsity_pattern,
std::vector<unsigned int> &color_indices);
} // namespace GraphColoring
* Create dataset. This is an internal constructor. The function
* Group::create_dataset() should be used to create a dataset.
*/
- DataSet(const std::string & name,
- const hid_t & parent_group_id,
- const std::vector<hsize_t> & dimensions,
+ DataSet(const std::string &name,
+ const hid_t &parent_group_id,
+ const std::vector<hsize_t> &dimensions,
const std::shared_ptr<hid_t> &t_type,
const bool mpi);
*/
template <typename Container>
void
- write_selection(const Container & data,
+ write_selection(const Container &data,
const std::vector<hsize_t> &coordinates);
// clang-format off
// clang-format on
template <typename Container>
void
- write_hyperslab(const Container & data,
+ write_hyperslab(const Container &data,
const std::vector<hsize_t> &offset,
const std::vector<hsize_t> &count);
*/
template <typename Container>
void
- write_hyperslab(const Container & data,
+ write_hyperslab(const Container &data,
const std::vector<hsize_t> &data_dimensions,
const std::vector<hsize_t> &offset,
const std::vector<hsize_t> &stride,
* create_group() of the current class should be used to open or create a
* group.
*/
- Group(const std::string & name,
- const Group & parent_group,
+ Group(const std::string &name,
+ const Group &parent_group,
const bool mpi,
const GroupAccessMode mode);
*/
template <typename number>
DataSet
- create_dataset(const std::string & name,
+ create_dataset(const std::string &name,
const std::vector<hsize_t> &dimensions) const;
/**
* defines the processes that participate in this call; `MPI_COMM_WORLD` is
* a common value for the MPI communicator.
*/
- File(const std::string & name,
+ File(const std::string &name,
const FileAccessMode mode,
const MPI_Comm mpi_communicator);
* File(const std::string &, const Mode)
* should be used to open or create HDF5 files.
*/
- File(const std::string & name,
+ File(const std::string &name,
const FileAccessMode mode,
const bool mpi,
const MPI_Comm mpi_communicator);
* been collective.
*/
inline void
- release_plist(hid_t & plist,
+ release_plist(hid_t &plist,
H5D_mpio_actual_io_mode_t &io_mode,
- std::uint32_t & local_no_collective_cause,
- std::uint32_t & global_no_collective_cause,
+ std::uint32_t &local_no_collective_cause,
+ std::uint32_t &global_no_collective_cause,
const bool mpi,
const bool query_io_mode);
inline void
- release_plist(hid_t & plist,
+ release_plist(hid_t &plist,
H5D_mpio_actual_io_mode_t &io_mode,
- std::uint32_t & local_no_collective_cause,
- std::uint32_t & global_no_collective_cause,
+ std::uint32_t &local_no_collective_cause,
+ std::uint32_t &global_no_collective_cause,
const bool mpi,
const bool query_io_mode)
{
// Todo:
// - Use H5Dvlen_reclaim instead of free
- char * string_out;
+ char *string_out;
hid_t attr;
hid_t type;
herr_t ret;
template <typename Container>
void
- DataSet::write_selection(const Container & data,
+ DataSet::write_selection(const Container &data,
const std::vector<hsize_t> &coordinates)
{
AssertDimension(coordinates.size(), data.size() * rank);
template <typename Container>
void
- DataSet::write_hyperslab(const Container & data,
+ DataSet::write_hyperslab(const Container &data,
const std::vector<hsize_t> &offset,
const std::vector<hsize_t> &count)
{
template <typename Container>
void
- DataSet::write_hyperslab(const Container & data,
+ DataSet::write_hyperslab(const Container &data,
const std::vector<hsize_t> &data_dimensions,
const std::vector<hsize_t> &offset,
const std::vector<hsize_t> &stride,
template <typename number>
DataSet
- Group::create_dataset(const std::string & name,
+ Group::create_dataset(const std::string &name,
const std::vector<hsize_t> &dimensions) const
{
std::shared_ptr<hid_t> t_type = internal::get_hdf5_datatype<number>();
* this function is called.
*/
virtual void
- vector_value(const Point<dim> & p,
+ vector_value(const Point<dim> &p,
Vector<RangeNumberType> &values) const override;
/**
void
add_ranges_internal(
boost::container::small_vector<std::pair<size_type, size_type>, 200>
- & tmp_ranges,
+ &tmp_ranges,
const bool ranges_are_sorted);
};
/* IntervalAccessor */
inline IndexSet::IntervalAccessor::IntervalAccessor(
- const IndexSet * idxset,
+ const IndexSet *idxset,
const IndexSet::size_type range_idx)
: index_set(idxset)
, range_idx(range_idx)
/* IntervalIterator */
inline IndexSet::IntervalIterator::IntervalIterator(
- const IndexSet * idxset,
+ const IndexSet *idxset,
const IndexSet::size_type range_idx)
: accessor(idxset, range_idx)
{}
/* ElementIterator */
inline IndexSet::ElementIterator::ElementIterator(
- const IndexSet * idxset,
+ const IndexSet *idxset,
const IndexSet::size_type range_idx,
const IndexSet::size_type index)
: index_set(idxset)
*/
template <typename BaseIterator>
IteratorRange<BaseIterator>
-make_iterator_range(const BaseIterator & begin,
+make_iterator_range(const BaseIterator &begin,
const std_cxx20::type_identity_t<BaseIterator> &end)
{
IteratorRange<BaseIterator> ir(begin, end);
LinearIndexIterator<DerivedIterator, AccessorType>::operator++(int)
{
const DerivedIterator copy(this->accessor);
- operator+=(1);
+ operator+=(1);
return copy;
}
LinearIndexIterator<DerivedIterator, AccessorType>::operator--(int)
{
const DerivedIterator copy(this->accessor);
- operator+=(-1);
+ operator+=(-1);
return copy;
}
* @param[in] flags Format flags to set on the output stream @p o.
*/
void
- attach(std::ostream & o,
+ attach(std::ostream &o,
const bool print_job_id = true,
const std::ios_base::fmtflags flags = std::ios::showpoint |
std::ios::left);
template <typename T, typename MemorySpace>
void
- MemorySpaceData<T, MemorySpace>::copy_to(T * begin,
+ MemorySpaceData<T, MemorySpace>::copy_to(T *begin,
const std::size_t n_elements)
{
Assert(n_elements <= values.extent(0),
template <typename T, typename MemorySpace>
void
- MemorySpaceData<T, MemorySpace>::copy_from(const T * begin,
+ MemorySpaceData<T, MemorySpace>::copy_from(const T *begin,
const std::size_t n_elements)
{
Assert(n_elements <= values.extent(0),
create_group(const MPI_Comm comm,
const MPI_Group &group,
const int tag,
- MPI_Comm * new_comm);
+ MPI_Comm *new_comm);
#endif
/**
void
sum(const ArrayView<const T> &values,
const MPI_Comm mpi_communicator,
- const ArrayView<T> & sums);
+ const ArrayView<T> &sums);
/**
* Perform an MPI sum of the entries of a symmetric tensor.
void
sum(const SparseMatrix<Number> &local,
const MPI_Comm mpi_communicator,
- SparseMatrix<Number> & global);
+ SparseMatrix<Number> &global);
/**
* Return the maximum over all processors of the value @p t. This function
void
max(const ArrayView<const T> &values,
const MPI_Comm mpi_communicator,
- const ArrayView<T> & maxima);
+ const ArrayView<T> &maxima);
/**
* Return the minimum over all processors of the value @p t. This function
void
min(const ArrayView<const T> &values,
const MPI_Comm mpi_communicator,
- const ArrayView<T> & minima);
+ const ArrayView<T> &minima);
/**
* Performs a <i>logical or</i> operation over all processors of the value
void
logical_or(const ArrayView<const T> &values,
const MPI_Comm mpi_communicator,
- const ArrayView<T> & results);
+ const ArrayView<T> &results);
/**
* A data structure to store the result of the min_max_avg() function.
*/
void
min_max_avg(const ArrayView<const double> &my_values,
- const ArrayView<MinMaxAvg> & result,
+ const ArrayView<MinMaxAvg> &result,
const MPI_Comm mpi_communicator);
* <code>main()</code>.
*/
MPI_InitFinalize(
- int & argc,
- char **& argv,
+ int &argc,
+ char **&argv,
const unsigned int max_num_threads = numbers::invalid_unsigned_int);
/**
template <typename T>
std::vector<T>
gather(const MPI_Comm comm,
- const T & object_to_send,
+ const T &object_to_send,
const unsigned int root_process = 0);
/**
template <typename T>
std::enable_if_t<is_mpi_type<T> == false, T>
broadcast(const MPI_Comm comm,
- const T & object_to_send,
+ const T &object_to_send,
const unsigned int root_process = 0);
/**
template <typename T>
std::enable_if_t<is_mpi_type<T> == true, T>
broadcast(const MPI_Comm comm,
- const T & object_to_send,
+ const T &object_to_send,
const unsigned int root_process = 0);
/**
*/
template <typename T>
void
- broadcast(T * buffer,
+ broadcast(T *buffer,
const size_t count,
const unsigned int root,
const MPI_Comm comm);
*/
template <typename T>
T
- reduce(const T & local_value,
+ reduce(const T &local_value,
const MPI_Comm comm,
const std::function<T(const T &, const T &)> &combiner,
const unsigned int root_process = 0);
*/
template <typename T>
T
- all_reduce(const T & local_value,
+ all_reduce(const T &local_value,
const MPI_Comm comm,
const std::function<T(const T &, const T &)> &combiner);
*/
template <typename T>
Future<void>
- isend(const T & object,
+ isend(const T &object,
MPI_Comm communicator,
const unsigned int target_rank,
const unsigned int mpi_tag = 0);
* not satisfied.
*/
template <typename T>
- const MPI_Datatype
- mpi_type_id_for_type = internal::MPIDataTypes::mpi_type_id(
+ const MPI_Datatype mpi_type_id_for_type =
+ internal::MPIDataTypes::mpi_type_id(
static_cast<std::remove_cv_t<std::remove_reference_t<T>> *>(nullptr));
#endif
// declaration for an internal function that lives in mpi.templates.h
template <typename T>
void
- all_reduce(const MPI_Op & mpi_op,
+ all_reduce(const MPI_Op &mpi_op,
const ArrayView<const T> &values,
const MPI_Comm mpi_communicator,
- const ArrayView<T> & output);
+ const ArrayView<T> &output);
} // namespace internal
template <typename T>
std::vector<T>
gather(const MPI_Comm comm,
- const T & object_to_send,
+ const T &object_to_send,
const unsigned int root_process)
{
# ifndef DEAL_II_WITH_MPI
template <typename T>
void
- broadcast(T * buffer,
+ broadcast(T *buffer,
const size_t count,
const unsigned int root,
const MPI_Comm comm)
template <typename T>
std::enable_if_t<is_mpi_type<T> == false, T>
broadcast(const MPI_Comm comm,
- const T & object_to_send,
+ const T &object_to_send,
const unsigned int root_process)
{
# ifndef DEAL_II_WITH_MPI
template <typename T>
std::enable_if_t<is_mpi_type<T> == true, T>
broadcast(const MPI_Comm comm,
- const T & object_to_send,
+ const T &object_to_send,
const unsigned int root_process)
{
# ifndef DEAL_II_WITH_MPI
template <typename T>
Future<void>
- isend(const T & object,
+ isend(const T &object,
MPI_Comm communicator,
const unsigned int target_rank,
const unsigned int mpi_tag)
{
template <typename T>
void
- all_reduce(const MPI_Op & mpi_op,
+ all_reduce(const MPI_Op &mpi_op,
const ArrayView<const T> &values,
const MPI_Comm mpi_communicator,
- const ArrayView<T> & output)
+ const ArrayView<T> &output)
{
AssertDimension(values.size(), output.size());
#ifdef DEAL_II_WITH_MPI
template <typename T>
void
- all_reduce(const MPI_Op & mpi_op,
+ all_reduce(const MPI_Op &mpi_op,
const ArrayView<const std::complex<T>> &values,
const MPI_Comm mpi_communicator,
- const ArrayView<std::complex<T>> & output)
+ const ArrayView<std::complex<T>> &output)
{
AssertDimension(values.size(), output.size());
#ifdef DEAL_II_WITH_MPI
void
sum(const ArrayView<const T> &values,
const MPI_Comm mpi_communicator,
- const ArrayView<T> & sums)
+ const ArrayView<T> &sums)
{
internal::all_reduce(MPI_SUM, values, mpi_communicator, sums);
}
void
sum(const SparseMatrix<Number> &local,
const MPI_Comm mpi_communicator,
- SparseMatrix<Number> & global)
+ SparseMatrix<Number> &global)
{
Assert(
local.get_sparsity_pattern() == global.get_sparsity_pattern(),
void
max(const ArrayView<const T> &values,
const MPI_Comm mpi_communicator,
- const ArrayView<T> & maxima)
+ const ArrayView<T> &maxima)
{
internal::all_reduce(MPI_MAX, values, mpi_communicator, maxima);
}
void
min(const ArrayView<const T> &values,
const MPI_Comm mpi_communicator,
- const ArrayView<T> & minima)
+ const ArrayView<T> &minima)
{
internal::all_reduce(MPI_MIN, values, mpi_communicator, minima);
}
void
logical_or(const ArrayView<const T> &values,
const MPI_Comm mpi_communicator,
- const ArrayView<T> & results)
+ const ArrayView<T> &results)
{
static_assert(std::is_integral_v<T>,
"The MPI_LOR operation only allows integral data types.");
template <typename T>
T
- reduce(const T & vec,
+ reduce(const T &vec,
const MPI_Comm comm,
const std::function<T(const T &, const T &)> &combiner,
const unsigned int root_process)
template <typename T>
T
- all_reduce(const T & vec,
+ all_reduce(const T &vec,
const MPI_Comm comm,
const std::function<T(const T &, const T &)> &combiner)
{
append_index_origin(const unsigned int index_within_dictionary,
const unsigned int rank_of_request,
const unsigned int rank_of_owner,
- unsigned int & owner_index_guess);
+ unsigned int &owner_index_guess);
};
/* ------------------------- inline functions ----------------------- */
virtual void
answer_request(const unsigned int other_rank,
const RequestType &buffer_recv,
- AnswerType & request_buffer);
+ AnswerType &request_buffer);
/**
* Process the payload of the answer of the request to the process with
*/
virtual void
read_answer(const unsigned int other_rank,
- const AnswerType & recv_buffer);
+ const AnswerType &recv_buffer);
};
*/
virtual std::vector<unsigned int>
run(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int,
const RequestType &)> &answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm) = 0;
};
*/
virtual std::vector<unsigned int>
run(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int,
const RequestType &)> &answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm) override;
private:
bool
all_locally_originated_receives_are_completed(
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm);
/**
*/
void
start_communication(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const MPI_Comm comm);
*/
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
- nbx(const std::vector<unsigned int> & targets,
+ nbx(const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int,
const RequestType &)> &answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm);
/**
*/
template <typename RequestType>
std::vector<unsigned int>
- nbx(const std::vector<unsigned int> & targets,
+ nbx(const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<void(const unsigned int, const RequestType &)>
- & process_request,
+ &process_request,
const MPI_Comm comm);
/**
*/
virtual std::vector<unsigned int>
run(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int,
const RequestType &)> &answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm) override;
private:
*/
unsigned int
start_communication(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const MPI_Comm comm);
process_incoming_answers(
const unsigned int n_targets,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm);
/**
*/
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
- pex(const std::vector<unsigned int> & targets,
+ pex(const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int,
const RequestType &)> &answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm);
/**
*/
template <typename RequestType>
std::vector<unsigned int>
- pex(const std::vector<unsigned int> & targets,
+ pex(const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<void(const unsigned int, const RequestType &)>
- & process_request,
+ &process_request,
const MPI_Comm comm);
*/
virtual std::vector<unsigned int>
run(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int,
const RequestType &)> &answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm) override;
};
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
serial(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int, const RequestType &)>
&answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm);
/**
template <typename RequestType>
std::vector<unsigned int>
serial(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<void(const unsigned int, const RequestType &)>
- & process_request,
+ &process_request,
const MPI_Comm comm);
*/
virtual std::vector<unsigned int>
run(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int,
const RequestType &)> &answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm) override;
private:
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
selector(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int, const RequestType &)>
&answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm);
/**
template <typename RequestType>
std::vector<unsigned int>
selector(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<void(const unsigned int, const RequestType &)>
- & process_request,
+ &process_request,
const MPI_Comm comm);
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
- nbx(const std::vector<unsigned int> & targets,
+ nbx(const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int,
const RequestType &)> &answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm)
{
return NBX<RequestType, AnswerType>().run(
template <typename RequestType>
std::vector<unsigned int>
- nbx(const std::vector<unsigned int> & targets,
+ nbx(const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<void(const unsigned int, const RequestType &)>
- & process_request,
+ &process_request,
const MPI_Comm comm)
{
// TODO: For the moment, simply implement this special case by
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
- pex(const std::vector<unsigned int> & targets,
+ pex(const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int,
const RequestType &)> &answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm)
{
return PEX<RequestType, AnswerType>().run(
template <typename RequestType>
std::vector<unsigned int>
- pex(const std::vector<unsigned int> & targets,
+ pex(const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<void(const unsigned int, const RequestType &)>
- & process_request,
+ &process_request,
const MPI_Comm comm)
{
// TODO: For the moment, simply implement this special case by
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
serial(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int, const RequestType &)>
&answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm)
{
return Serial<RequestType, AnswerType>().run(
template <typename RequestType>
std::vector<unsigned int>
serial(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<void(const unsigned int, const RequestType &)>
- & process_request,
+ &process_request,
const MPI_Comm comm)
{
// TODO: For the moment, simply implement this special case by
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
selector(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int, const RequestType &)>
&answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm)
{
return Selector<RequestType, AnswerType>().run(
template <typename RequestType>
std::vector<unsigned int>
selector(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<void(const unsigned int, const RequestType &)>
- & process_request,
+ &process_request,
const MPI_Comm comm)
{
// TODO: For the moment, simply implement this special case by
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
NBX<RequestType, AnswerType>::run(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int, const RequestType &)>
&answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm)
{
Assert(has_unique_elements(targets),
template <typename RequestType, typename AnswerType>
void
NBX<RequestType, AnswerType>::start_communication(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const MPI_Comm comm)
{
NBX<RequestType, AnswerType>::
all_locally_originated_receives_are_completed(
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm)
{
# ifdef DEAL_II_WITH_MPI
void
NBX<RequestType, AnswerType>::maybe_answer_one_request(
const std::function<AnswerType(const unsigned int, const RequestType &)>
- & answer_request,
+ &answer_request,
const MPI_Comm comm)
{
# ifdef DEAL_II_WITH_MPI
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
PEX<RequestType, AnswerType>::run(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int, const RequestType &)>
&answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm)
{
Assert(has_unique_elements(targets),
template <typename RequestType, typename AnswerType>
unsigned int
PEX<RequestType, AnswerType>::start_communication(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const MPI_Comm comm)
{
PEX<RequestType, AnswerType>::answer_one_request(
const unsigned int index,
const std::function<AnswerType(const unsigned int, const RequestType &)>
- & answer_request,
+ &answer_request,
const MPI_Comm comm)
{
# ifdef DEAL_II_WITH_MPI
PEX<RequestType, AnswerType>::process_incoming_answers(
const unsigned int n_targets,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm)
{
# ifdef DEAL_II_WITH_MPI
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
Serial<RequestType, AnswerType>::run(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int, const RequestType &)>
&answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm)
{
(void)comm;
template <typename RequestType, typename AnswerType>
std::vector<unsigned int>
Selector<RequestType, AnswerType>::run(
- const std::vector<unsigned int> & targets,
+ const std::vector<unsigned int> &targets,
const std::function<RequestType(const unsigned int)> &create_request,
const std::function<AnswerType(const unsigned int, const RequestType &)>
&answer_request,
const std::function<void(const unsigned int, const AnswerType &)>
- & process_answer,
+ &process_answer,
const MPI_Comm comm)
{
// Depending on the number of processes we switch between
int blocklengths[2] = {1, 1};
MPI_Aint displacements[2] = {0,
- static_cast<MPI_Aint>(n_chunks) *
- size_old * max_signed_int};
+ static_cast<MPI_Aint>(n_chunks) *
+ size_old * max_signed_int};
MPI_Datatype types[2] = {chunks, remainder};
ierr = MPI_Type_create_struct(
2, blocklengths, displacements, types, newtype);
* See the MPI 4.x standard for details.
*/
inline int
- Send_c(const void * buf,
+ Send_c(const void *buf,
MPI_Count count,
MPI_Datatype datatype,
int dest,
* See the MPI 4.x standard for details.
*/
inline int
- Recv_c(void * buf,
+ Recv_c(void *buf,
MPI_Count count,
MPI_Datatype datatype,
int source,
int tag,
MPI_Comm comm,
- MPI_Status * status)
+ MPI_Status *status)
{
# if MPI_VERSION >= 4
return MPI_Recv_c(buf, count, datatype, source, tag, comm, status);
* See the MPI 4.x standard for details.
*/
inline int
- Bcast_c(void * buf,
+ Bcast_c(void *buf,
MPI_Count count,
MPI_Datatype datatype,
unsigned int root_mpi_rank,
inline int
File_write_at_c(MPI_File fh,
MPI_Offset offset,
- const void * buf,
+ const void *buf,
MPI_Count count,
MPI_Datatype datatype,
- MPI_Status * status)
+ MPI_Status *status)
{
if (count <= LargeCount::mpi_max_int_count)
return MPI_File_write_at(fh, offset, buf, count, datatype, status);
inline int
File_write_at_all_c(MPI_File fh,
MPI_Offset offset,
- const void * buf,
+ const void *buf,
MPI_Count count,
MPI_Datatype datatype,
- MPI_Status * status)
+ MPI_Status *status)
{
if (count <= LargeCount::mpi_max_int_count)
return MPI_File_write_at_all(
*/
inline int
File_write_ordered_c(MPI_File fh,
- const void * buf,
+ const void *buf,
MPI_Count count,
MPI_Datatype datatype,
- MPI_Status * status)
+ MPI_Status *status)
{
if (count <= LargeCount::mpi_max_int_count)
return MPI_File_write_ordered(fh, buf, count, datatype, status);
inline int
File_read_at_c(MPI_File fh,
MPI_Offset offset,
- void * buf,
+ void *buf,
MPI_Count count,
MPI_Datatype datatype,
- MPI_Status * status)
+ MPI_Status *status)
{
if (count <= LargeCount::mpi_max_int_count)
return MPI_File_read_at(fh, offset, buf, count, datatype, status);
inline int
File_read_at_all_c(MPI_File fh,
MPI_Offset offset,
- void * buf,
+ void *buf,
MPI_Count count,
MPI_Datatype datatype,
- MPI_Status * status)
+ MPI_Status *status)
{
if (count <= LargeCount::mpi_max_int_count)
return MPI_File_read_at_all(fh, offset, buf, count, datatype, status);
void
export_to_ghosted_array(
const ArrayView<const Number> &locally_owned_array,
- const ArrayView<Number> & ghost_array) const;
+ const ArrayView<Number> &ghost_array) const;
/**
* Same as above but with an interface similar to
export_to_ghosted_array(
const unsigned int communication_channel,
const ArrayView<const Number> &locally_owned_array,
- const ArrayView<Number> & temporary_storage,
- const ArrayView<Number> & ghost_array,
- std::vector<MPI_Request> & requests) const;
+ const ArrayView<Number> &temporary_storage,
+ const ArrayView<Number> &ghost_array,
+ std::vector<MPI_Request> &requests) const;
/**
* Start update: Data is packed, non-blocking send and receives
export_to_ghosted_array_start(
const unsigned int communication_channel,
const ArrayView<const Number> &locally_owned_array,
- const ArrayView<Number> & temporary_storage,
- std::vector<MPI_Request> & requests) const;
+ const ArrayView<Number> &temporary_storage,
+ std::vector<MPI_Request> &requests) const;
/**
* Finish update. The method waits until all data has been sent and
void
export_to_ghosted_array_finish(
const ArrayView<const Number> &temporary_storage,
- const ArrayView<Number> & ghost_array,
- std::vector<MPI_Request> & requests) const;
+ const ArrayView<Number> &ghost_array,
+ std::vector<MPI_Request> &requests) const;
/**
* Similar to the above functions but for importing vector entries
void
import_from_ghosted_array(
const VectorOperation::values vector_operation,
- const ArrayView<Number> & ghost_array,
- const ArrayView<Number> & locally_owned_storage) const;
+ const ArrayView<Number> &ghost_array,
+ const ArrayView<Number> &locally_owned_storage) const;
/**
* Similar to the above function with the difference that
void
import_from_ghosted_array(const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<Number> & ghost_array,
- const ArrayView<Number> & temporary_storage,
- const ArrayView<Number> & locally_owned_storage,
+ const ArrayView<Number> &ghost_array,
+ const ArrayView<Number> &temporary_storage,
+ const ArrayView<Number> &locally_owned_storage,
std::vector<MPI_Request> &requests) const;
/**
import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<Number> & ghost_array,
- const ArrayView<Number> & temporary_storage,
- std::vector<MPI_Request> & requests) const;
+ const ArrayView<Number> &ghost_array,
+ const ArrayView<Number> &temporary_storage,
+ std::vector<MPI_Request> &requests) const;
/**
* Finish update for importing values. The method waits until all data has
import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
const ArrayView<const Number> &temporary_storage,
- const ArrayView<Number> & locally_owned_storage,
- std::vector<MPI_Request> & requests) const;
+ const ArrayView<Number> &locally_owned_storage,
+ std::vector<MPI_Request> &requests) const;
/**
* Returns the number of processes this process sends data to and the
void
NoncontiguousPartitioner::export_to_ghosted_array(
const ArrayView<const Number> &src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &dst) const
{
// allocate internal memory since needed
if (requests.size() != send_ranks.size() + recv_ranks.size())
NoncontiguousPartitioner::export_to_ghosted_array(
const unsigned int communication_channel,
const ArrayView<const Number> &locally_owned_array,
- const ArrayView<Number> & temporary_storage,
- const ArrayView<Number> & ghost_array,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number> &temporary_storage,
+ const ArrayView<Number> &ghost_array,
+ std::vector<MPI_Request> &requests) const
{
this->template export_to_ghosted_array_start<Number>(
communication_channel,
NoncontiguousPartitioner::export_to_ghosted_array_start(
const unsigned int communication_channel,
const ArrayView<const Number> &src,
- const ArrayView<Number> & buffers,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number> &buffers,
+ std::vector<MPI_Request> &requests) const
{
#ifndef DEAL_II_WITH_MPI
(void)communication_channel;
void
NoncontiguousPartitioner::export_to_ghosted_array_finish(
const ArrayView<const Number> &buffers,
- const ArrayView<Number> & dst,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number> &dst,
+ std::vector<MPI_Request> &requests) const
{
#ifndef DEAL_II_WITH_MPI
(void)buffers;
void
NoncontiguousPartitioner::import_from_ghosted_array(
const VectorOperation::values vector_operation,
- const ArrayView<Number> & src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &src,
+ const ArrayView<Number> &dst) const
{
// allocate internal memory since needed
if (requests.size() != send_ranks.size() + recv_ranks.size())
NoncontiguousPartitioner::import_from_ghosted_array(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<Number> & ghost_array,
- const ArrayView<Number> & temporary_storage,
- const ArrayView<Number> & locally_owned_array,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number> &ghost_array,
+ const ArrayView<Number> &temporary_storage,
+ const ArrayView<Number> &locally_owned_array,
+ std::vector<MPI_Request> &requests) const
{
this->template import_from_ghosted_array_start<Number>(
vector_operation,
NoncontiguousPartitioner::import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<Number> & src,
- const ArrayView<Number> & buffers,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number> &src,
+ const ArrayView<Number> &buffers,
+ std::vector<MPI_Request> &requests) const
{
#ifndef DEAL_II_WITH_MPI
(void)vector_operation;
NoncontiguousPartitioner::import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
const ArrayView<const Number> &buffers,
- const ArrayView<Number> & dst,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number> &dst,
+ std::vector<MPI_Request> &requests) const
{
#ifndef DEAL_II_WITH_MPI
(void)vector_operation;
void
reinit(const std::vector<Point<spacedim>> &points,
const Triangulation<dim, spacedim> &tria,
- const Mapping<dim, spacedim> & mapping);
+ const Mapping<dim, spacedim> &mapping);
/**
* Set up internal data structures and communication pattern based on
void
reinit(const GridTools::internal::
DistributedComputePointLocationsInternal<dim, spacedim> &data,
- const Triangulation<dim, spacedim> & tria,
+ const Triangulation<dim, spacedim> &tria,
const Mapping<dim, spacedim> &mapping);
/**
void
process_and_evaluate(
const std::vector<T> &input,
- std::vector<T> & buffer,
+ std::vector<T> &buffer,
const std::function<void(const ArrayView<const T> &, const CellData &)>
&evaluation_function) const;
void
RemotePointEvaluation<dim, spacedim>::process_and_evaluate(
const std::vector<T> &input,
- std::vector<T> & buffer,
+ std::vector<T> &buffer,
const std::function<void(const ArrayView<const T> &, const CellData &)>
&evaluation_function) const
{
* information.
*/
virtual void
- initialize(const std::string & vars,
- const std::vector<std::string> & expressions,
+ initialize(const std::string &vars,
+ const std::vector<std::string> &expressions,
const std::map<std::string, double> &constants,
const bool time_dependent = false);
* Compute the values of all components.
*/
void
- do_all_values(const Point<dim> & p,
+ do_all_values(const Point<dim> &p,
const double time,
ArrayView<Number> &values) const;
* the conversion
*/
void
- parse_arguments(const std::string & value_string,
+ parse_arguments(const std::string &value_string,
const Patterns::PatternBase &pattern =
*Patterns::Tools::Convert<TupleType>::to_pattern());
template <typename ReturnType, class... FunctionArgs>
template <typename FunctionType>
MutableBind<ReturnType, FunctionArgs...>::MutableBind(FunctionType function,
- TupleType && arguments)
+ TupleType &&arguments)
: function(function)
, arguments(std::move(arguments))
{}
template <typename ReturnType, class... FunctionArgs>
void
MutableBind<ReturnType, FunctionArgs...>::parse_arguments(
- const std::string & value_string,
+ const std::string &value_string,
const Patterns::PatternBase &pattern)
{
arguments =
template <typename ReturnType, class... FunctionArgs>
MutableBind<ReturnType, FunctionArgs...>
- mutable_bind(ReturnType (*function)(FunctionArgs...))
+ mutable_bind(ReturnType (*function)(FunctionArgs...))
{
return MutableBind<ReturnType, FunctionArgs...>(function);
}
* @note This function can also be used in @ref GlossDevice "device" code.
*/
static constexpr DEAL_II_HOST_DEVICE const number &
- conjugate(const number &x);
+ conjugate(const number &x);
/**
* Return the square of the absolute value of the given number. Since the
struct NumberType
{
static constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE const T &
- value(const T &t)
+ value(const T &t)
{
return t;
}
void
parallel_for(Iterator x_begin,
Iterator x_end,
- const Functor & functor,
+ const Functor &functor,
const unsigned int grainsize)
{
tbb::parallel_for(tbb::blocked_range<Iterator>(x_begin, x_end, grainsize),
void
parallel_for(Iterator x_begin,
Iterator x_end,
- const Functor & functor,
+ const Functor &functor,
const unsigned int grainsize,
const std::shared_ptr<tbb::affinity_partitioner> &partitioner)
{
void transform(const InputIterator &begin_in,
const InputIterator &end_in,
OutputIterator out,
- const Function & function,
+ const Function &function,
const unsigned int grainsize)
{
#ifndef DEAL_II_WITH_TBB
const InputIterator1 &end_in1,
InputIterator2 in2,
OutputIterator out,
- const Function & function,
+ const Function &function,
const unsigned int grainsize)
{
#ifndef DEAL_II_WITH_TBB
InputIterator2 in2,
InputIterator3 in3,
OutputIterator out,
- const Function & function,
+ const Function &function,
const unsigned int grainsize)
{
#ifndef DEAL_II_WITH_TBB
template <typename Iterator, typename Function>
DEAL_II_CXX20_REQUIRES((std::invocable<Function, Iterator, Iterator>))
void apply_to_subranges(const tbb::blocked_range<Iterator> &range,
- const Function & f)
+ const Function &f)
{
f(range.begin(), range.end());
}
*/
template <typename Iterator, typename Function>
DEAL_II_CXX20_REQUIRES((std::invocable<Function, Iterator, Iterator>))
- void apply_to_subranges(const Iterator & begin,
+ void apply_to_subranges(const Iterator &begin,
const std_cxx20::type_identity_t<Iterator> &end,
- const Function & f,
+ const Function &f,
const unsigned int grainsize)
{
#ifndef DEAL_II_WITH_TBB
std::convertible_to<std::invoke_result_t<Function, Iterator, Iterator>,
ResultType>))
ResultType
- accumulate_from_subranges(const Function & f,
- const Iterator & begin,
+ accumulate_from_subranges(const Function &f,
+ const Iterator &begin,
const std_cxx20::type_identity_t<Iterator> &end,
const unsigned int grainsize)
{
const std::string &output_filename = "",
const ParameterHandler::OutputStyle
output_style_for_output_filename = ParameterHandler::Short,
- ParameterHandler & prm = ParameterAcceptor::prm,
+ ParameterHandler &prm = ParameterAcceptor::prm,
const ParameterHandler::OutputStyle output_style_for_filename =
ParameterHandler::DefaultStyle);
* @param prm The ParameterHandler to use
*/
static void
- initialize(std::istream & input_stream,
+ initialize(std::istream &input_stream,
ParameterHandler &prm = ParameterAcceptor::prm);
*/
template <typename ParameterType>
void
- add_parameter(const std::string & entry,
- ParameterType & parameter,
- const std::string & documentation = "",
- ParameterHandler & prm_ = prm,
+ add_parameter(const std::string &entry,
+ ParameterType ¶meter,
+ const std::string &documentation = "",
+ ParameterHandler &prm_ = prm,
const Patterns::PatternBase &pattern =
*Patterns::Tools::Convert<ParameterType>::to_pattern());
// Inline and template functions
template <typename ParameterType>
void
-ParameterAcceptor::add_parameter(const std::string & entry,
- ParameterType & parameter,
- const std::string & documentation,
- ParameterHandler & prm,
+ParameterAcceptor::add_parameter(const std::string &entry,
+ ParameterType ¶meter,
+ const std::string &documentation,
+ ParameterHandler &prm,
const Patterns::PatternBase &pattern)
{
enter_my_subsection(prm);
* value does not satisfy its pattern is ignored.
*/
virtual void
- parse_input(std::istream & input,
+ parse_input(std::istream &input,
const std::string &filename = "input file",
const std::string &last_line = "",
const bool skip_undefined = false);
* error, for example to override an earlier default value.
*/
void
- declare_entry(const std::string & entry,
- const std::string & default_value,
+ declare_entry(const std::string &entry,
+ const std::string &default_value,
const Patterns::PatternBase &pattern = Patterns::Anything(),
- const std::string & documentation = "",
+ const std::string &documentation = "",
const bool has_to_be_set = false);
/**
* ParameterHandler::parse_input() for more information.
*/
void
- add_action(const std::string & entry,
+ add_action(const std::string &entry,
const std::function<void(const std::string &value)> &action,
const bool execute_action = true);
*/
template <typename ParameterType>
void
- add_parameter(const std::string & entry,
- ParameterType & parameter,
- const std::string & documentation = "",
+ add_parameter(const std::string &entry,
+ ParameterType ¶meter,
+ const std::string &documentation = "",
const Patterns::PatternBase &pattern =
*Patterns::Tools::Convert<ParameterType>::to_pattern(),
const bool has_to_be_set = false);
*/
std::string
get(const std::vector<std::string> &entry_subsection_path,
- const std::string & entry_string) const;
+ const std::string &entry_string) const;
/**
* Return value of entry @p entry_string as <code>long int</code>. (A long
*/
long int
get_integer(const std::vector<std::string> &entry_subsection_path,
- const std::string & entry_string) const;
+ const std::string &entry_string) const;
/**
* Return value of entry @p entry_name as @p double.
*/
double
get_double(const std::vector<std::string> &entry_subsection_path,
- const std::string & entry_string) const;
+ const std::string &entry_string) const;
/**
* Return value of entry @p entry_name as @p bool. The entry may
* be "true" or "yes" for @p true, "false" or "no" for @p false
*/
bool
get_bool(const std::vector<std::string> &entry_subsection_path,
- const std::string & entry_string) const;
+ const std::string &entry_string) const;
/**
* Change the value presently stored for <tt>entry_name</tt> to the one
* it called recursively by the previous function.
*/
void
- log_parameters_section(LogStream & out,
+ log_parameters_section(LogStream &out,
const OutputStyle style = DefaultStyle);
/**
*/
std::string
get_current_full_path(const std::vector<std::string> &sub_path,
- const std::string & name) const;
+ const std::string &name) const;
/**
* Scan one line of input. <tt>input_filename</tt> and
*/
void
recursively_print_parameters(
- const boost::property_tree::ptree & tree,
- const std::vector<std::string> & target_subsection_path,
+ const boost::property_tree::ptree &tree,
+ const std::vector<std::string> &target_subsection_path,
const ParameterHandler::OutputStyle style,
const unsigned int indent_level,
- std::ostream & out) const;
+ std::ostream &out) const;
friend class MultipleParameterLoop;
};
* just reformat their inputs and then call this version.
*/
virtual void
- parse_input(std::istream & input,
+ parse_input(std::istream &input,
const std::string &filename = "input file",
const std::string &last_line = "",
const bool skip_undefined = false) override;
* <tt>split_different_values</tt>.
*/
Entry(const std::vector<std::string> &Path,
- const std::string & Name,
- const std::string & Value);
+ const std::string &Name,
+ const std::string &Value);
/**
* Split the entry value into the different branches.
ar &*entries.get();
std::vector<std::string> descriptions;
- ar & descriptions;
+ ar &descriptions;
patterns.clear();
for (const auto &description : descriptions)
template <typename ParameterType>
void
-ParameterHandler::add_parameter(const std::string & entry,
- ParameterType & parameter,
- const std::string & documentation,
+ParameterHandler::add_parameter(const std::string &entry,
+ ParameterType ¶meter,
+ const std::string &documentation,
const Patterns::PatternBase &pattern,
const bool has_to_be_set)
{
* unique component name.
*/
ParsedConvergenceTable(
- const std::vector<std::string> & component_names = {"u"},
+ const std::vector<std::string> &component_names = {"u"},
const std::vector<std::set<VectorTools::NormType>> &list_of_error_norms = {
{VectorTools::H1_norm, VectorTools::L2_norm, VectorTools::Linfty_norm}});
* @endcode
*/
ParsedConvergenceTable(
- const std::vector<std::string> & component_names,
+ const std::vector<std::string> &component_names,
const std::vector<std::set<VectorTools::NormType>> &list_of_error_norms,
const double exponent,
- const std::set<std::string> & extra_columns,
- const std::string & rate_key,
- const std::string & rate_mode,
- const std::string & error_file_name,
+ const std::set<std::string> &extra_columns,
+ const std::string &rate_key,
+ const std::string &rate_mode,
+ const std::string &error_file_name,
const unsigned int precision,
const bool compute_error);
template <int dim, int spacedim, typename VectorType>
void
error_from_exact(const DoFHandler<dim, spacedim> &vspace,
- const VectorType & solution,
- const Function<spacedim> & exact,
- const Function<spacedim> * weight = nullptr);
+ const VectorType &solution,
+ const Function<spacedim> &exact,
+ const Function<spacedim> *weight = nullptr);
/**
* Same as above, with a different mapping.
*/
template <int dim, int spacedim, typename VectorType>
void
- error_from_exact(const Mapping<dim, spacedim> & mapping,
+ error_from_exact(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &vspace,
- const VectorType & solution,
- const Function<spacedim> & exact,
- const Function<spacedim> * weight = nullptr);
+ const VectorType &solution,
+ const Function<spacedim> &exact,
+ const Function<spacedim> *weight = nullptr);
/**
* Add an additional column (with name @p column_name) to the table, by invoking
* key in the parameter file.
*/
void
- add_extra_column(const std::string & column_name,
+ add_extra_column(const std::string &column_name,
const std::function<double()> &custom_function,
const bool compute_rate = true);
template <int dim, int spacedim, typename VectorType>
void
ParsedConvergenceTable::difference(const DoFHandler<dim, spacedim> &dh,
- const VectorType & solution1,
- const VectorType & solution2,
- const Function<spacedim> * weight)
+ const VectorType &solution1,
+ const VectorType &solution2,
+ const Function<spacedim> *weight)
{
AssertThrow(solution1.size() == solution2.size(),
ExcDimensionMismatch(solution1.size(), solution2.size()));
template <int dim, int spacedim, typename VectorType>
void
-ParsedConvergenceTable::difference(const Mapping<dim, spacedim> & mapping,
+ParsedConvergenceTable::difference(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dh,
- const VectorType & solution1,
- const VectorType & solution2,
- const Function<spacedim> * weight)
+ const VectorType &solution1,
+ const VectorType &solution2,
+ const Function<spacedim> *weight)
{
AssertThrow(solution1.size() == solution2.size(),
ExcDimensionMismatch(solution1.size(), solution2.size()));
template <int dim, int spacedim, typename VectorType>
void
ParsedConvergenceTable::error_from_exact(const DoFHandler<dim, spacedim> &dh,
- const VectorType & solution,
+ const VectorType &solution,
const Function<spacedim> &exact,
const Function<spacedim> *weight)
{
void
ParsedConvergenceTable::error_from_exact(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dh,
- const VectorType & solution,
+ const VectorType &solution,
const Function<spacedim> &exact,
const Function<spacedim> *weight)
{
* @endcode
*/
static void
- declare_parameters(ParameterHandler & prm,
+ declare_parameters(ParameterHandler &prm,
const unsigned int n_components = 1);
/**
export_to_ghosted_array_start(
const unsigned int communication_channel,
const ArrayView<const Number, MemorySpaceType> &locally_owned_array,
- const ArrayView<Number, MemorySpaceType> & temporary_storage,
- const ArrayView<Number, MemorySpaceType> & ghost_array,
- std::vector<MPI_Request> & requests) const;
+ const ArrayView<Number, MemorySpaceType> &temporary_storage,
+ const ArrayView<Number, MemorySpaceType> &ghost_array,
+ std::vector<MPI_Request> &requests) const;
/**
* Finish the exportation of the data in a locally owned array to the
void
export_to_ghosted_array_finish(
const ArrayView<Number, MemorySpaceType> &ghost_array,
- std::vector<MPI_Request> & requests) const;
+ std::vector<MPI_Request> &requests) const;
/**
* Start importing the data on an array indexed by the ghost indices of
const unsigned int communication_channel,
const ArrayView<Number, MemorySpaceType> &ghost_array,
const ArrayView<Number, MemorySpaceType> &temporary_storage,
- std::vector<MPI_Request> & requests) const;
+ std::vector<MPI_Request> &requests) const;
/**
* Finish importing the data from an array indexed by the ghost
import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
const ArrayView<const Number, MemorySpaceType> &temporary_storage,
- const ArrayView<Number, MemorySpaceType> & locally_owned_storage,
- const ArrayView<Number, MemorySpaceType> & ghost_array,
- std::vector<MPI_Request> & requests) const;
+ const ArrayView<Number, MemorySpaceType> &locally_owned_storage,
+ const ArrayView<Number, MemorySpaceType> &ghost_array,
+ std::vector<MPI_Request> &requests) const;
#endif
/**
Partitioner::export_to_ghosted_array_start(
const unsigned int communication_channel,
const ArrayView<const Number, MemorySpaceType> &locally_owned_array,
- const ArrayView<Number, MemorySpaceType> & temporary_storage,
- const ArrayView<Number, MemorySpaceType> & ghost_array,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number, MemorySpaceType> &temporary_storage,
+ const ArrayView<Number, MemorySpaceType> &ghost_array,
+ std::vector<MPI_Request> &requests) const
{
AssertDimension(temporary_storage.size(), n_import_indices());
AssertIndexRange(communication_channel, 200);
void
Partitioner::export_to_ghosted_array_finish(
const ArrayView<Number, MemorySpaceType> &ghost_array,
- std::vector<MPI_Request> & requests) const
+ std::vector<MPI_Request> &requests) const
{
Assert(ghost_array.size() == n_ghost_indices() ||
ghost_array.size() == n_ghost_indices_in_larger_set,
const unsigned int communication_channel,
const ArrayView<Number, MemorySpaceType> &ghost_array,
const ArrayView<Number, MemorySpaceType> &temporary_storage,
- std::vector<MPI_Request> & requests) const
+ std::vector<MPI_Request> &requests) const
{
AssertDimension(temporary_storage.size(), n_import_indices());
AssertIndexRange(communication_channel, 200);
Partitioner::import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
const ArrayView<const Number, MemorySpaceType> &temporary_storage,
- const ArrayView<Number, MemorySpaceType> & locally_owned_array,
- const ArrayView<Number, MemorySpaceType> & ghost_array,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number, MemorySpaceType> &locally_owned_array,
+ const ArrayView<Number, MemorySpaceType> &ghost_array,
+ std::vector<MPI_Request> &requests) const
{
AssertDimension(temporary_storage.size(), n_import_indices());
Assert(ghost_array.size() == n_ghost_indices() ||
std::string
find(const std::string &filename,
const std::string &suffix,
- const char * open_mode = "r");
+ const char *open_mode = "r");
/**
* Show the paths and suffixes used for this object.
* Constructor.
*/
Tuple(const std::vector<std::unique_ptr<PatternBase>> &patterns,
- const std::string & separator = ":");
+ const std::string &separator = ":");
/**
* Constructor. Same as above, specialized for const char *. This is
* provided below.
*/
Tuple(const std::vector<std::unique_ptr<PatternBase>> &patterns,
- const char * separator);
+ const char *separator);
/**
* class template for particular kinds of template arguments @p T.
*/
static std::string
- to_string(const T & s,
+ to_string(const T &s,
const Patterns::PatternBase &p = *Convert<T>::to_pattern()) =
delete;
* class template for particular kinds of template arguments @p T.
*/
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &p = *Convert<T>::to_pattern()) =
delete;
};
}
static std::string
- to_string(const T & value,
+ to_string(const T &value,
const Patterns::PatternBase &p = *Convert<T>::to_pattern())
{
std::stringstream str;
}
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &p = *Convert<T>::to_pattern())
{
AssertThrow(p.match(s), ExcNoMatch(s, p.description()));
static std::string
to_string(
- const T & t,
+ const T &t,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
}
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
static std::string
to_string(
- const T & t,
+ const T &t,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
const auto *p = dynamic_cast<const Patterns::Map *>(&pattern);
}
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
static std::string
to_string(
- const T & t,
+ const T &t,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
}
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
static std::string
to_string(
- const T & t,
+ const T &t,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
}
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
static std::string
to_string(
- const T & t,
+ const T &t,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
return Convert<Tensor<1, dim, Number>>::to_string(
}
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
return T(Convert<Tensor<1, dim, Number>>::to_value(s, pattern));
static std::string
to_string(
- const T & t,
+ const T &t,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
}
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
static std::string
to_string(
- const T & t,
+ const T &t,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
std::vector<bool> mask(t.size());
}
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
const auto mask = Convert<std::vector<bool>>::to_value(s, pattern);
static std::string
to_string(
- const T & t,
+ const T &t,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
* Convert a string to a value, using the given pattern, or a default one.
*/
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
static std::string
to_string(
- const T & t,
+ const T &t,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
AssertThrow(pattern.match(t), ExcNoMatch(t, pattern.description()));
}
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
static std::string
to_string(
- const T & t,
+ const T &t,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
std::tuple<Key, Value> m(t);
}
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
std::tuple<Key, Value> m;
static std::string
to_string(
- const T & t,
+ const T &t,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
const auto *p = dynamic_cast<const Patterns::Tuple *>(&pattern);
}
static T
- to_value(const std::string & s,
+ to_value(const std::string &s,
const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
{
AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
private:
template <std::size_t... U>
static std::array<std::string, std::tuple_size<T>::value>
- to_string_internal_1(const T & t,
+ to_string_internal_1(const T &t,
const Patterns::Tuple &pattern,
std::index_sequence<U...>)
{
template <std::size_t... U>
static T
to_value_internal_1(const std::vector<std::string> &s,
- const Patterns::Tuple & pattern,
+ const Patterns::Tuple &pattern,
std::index_sequence<U...>)
{
return std::make_tuple(
static T
to_value_internal_2(const std::vector<std::string> &s,
- const Patterns::Tuple & pattern)
+ const Patterns::Tuple &pattern)
{
return Convert<T>::to_value_internal_1(
s, pattern, std::make_index_sequence<std::tuple_size<T>::value>{});
* @note This function can also be used in @ref GlossDevice "device" code.
*/
DEAL_II_HOST_DEVICE Number &
- operator()(const unsigned int index);
+ operator()(const unsigned int index);
/**
* Assignment operator from Tensor<1, dim, Number> with different underlying
void
value(const Number2 x,
const unsigned int n_derivatives,
- Number2 * values) const;
+ Number2 *values) const;
/**
* Similar to the function above, but evaluate the polynomials on several
void
values_of_array(const std::array<Number2, n_entries> &points,
const unsigned int n_derivatives,
- std::array<Number2, n_entries> * values) const;
+ std::array<Number2, n_entries> *values) const;
/**
* Degree of the polynomial. This is the degree reflected by the number of
inline void
Polynomial<number>::value(const Number2 x,
const unsigned int n_derivatives,
- Number2 * values) const
+ Number2 *values) const
{
values_of_array(std::array<Number2, 1ul>{{x}},
n_derivatives,
Polynomial<number>::values_of_array(
const std::array<Number2, n_entries> &x,
const unsigned int n_derivatives,
- std::array<Number2, n_entries> * values) const
+ std::array<Number2, n_entries> *values) const
{
// evaluate Lagrange polynomial and derivatives
if (in_lagrange_product_form == true)
* compute_grad_grad() functions, see below, in a loop over all polynomials.
*/
void
- evaluate(const Point<dim> & unit_point,
- std::vector<double> & values,
+ evaluate(const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
*/
virtual Tensor<1, dim>
compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
*/
virtual Tensor<2, dim>
compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
*/
virtual Tensor<3, dim>
compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_4th_derivative()
*/
virtual Tensor<4, dim>
compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* Compute the gradient of the <tt>i</tt>th polynomial at unit point
template <int order>
Tensor<order, dim>
PolynomialSpace<dim>::compute_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const std::array<unsigned int, dim> indices = compute_index(i);
template <int dim>
inline Tensor<1, dim>
PolynomialSpace<dim>::compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<1>(i, p);
}
template <int dim>
inline Tensor<2, dim>
PolynomialSpace<dim>::compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<2>(i, p);
}
template <int dim>
inline Tensor<3, dim>
PolynomialSpace<dim>::compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<3>(i, p);
}
template <int dim>
inline Tensor<4, dim>
PolynomialSpace<dim>::compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<4>(i, p);
}
* the first case, the function will not compute these values.
*/
void
- evaluate(const Point<dim> & unit_point,
+ evaluate(const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
* compute_grad_grad() functions, see below, in a loop over all polynomials.
*/
void
- evaluate(const Point<dim> & unit_point,
- std::vector<double> & values,
+ evaluate(const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
*/
virtual Tensor<1, dim>
compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
*/
virtual Tensor<2, dim>
compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
*/
virtual Tensor<3, dim>
compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_4th_derivative()
*/
virtual Tensor<4, dim>
compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* Compute the gradient of the <tt>i</tt>th polynomial at
* exponents).
*/
static TableIndices<dim + 1>
- index_to_indices(const std::size_t & index,
+ index_to_indices(const std::size_t &index,
const TableIndices<dim + 1> &extent);
};
* @copydoc ScalarPolynomialsBase::evaluate()
*/
void
- evaluate(const Point<dim> & unit_point,
- std::vector<double> & values,
+ evaluate(const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
*/
Tensor<1, dim>
compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
*/
Tensor<2, dim>
compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
*/
Tensor<3, dim>
compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_4th_derivative()
*/
Tensor<4, dim>
compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_grad()
const auto &coef_1 = this->coefficients;
const auto &coef_2 = multiplicand.coefficients;
- auto & coef_out = result.coefficients;
+ auto &coef_out = result.coefficients;
for (std::size_t i1 = 0; i1 < coef_1.n_elements(); ++i1)
{
deg[coordinate] -= 1;
BarycentricPolynomial<dim, Number> result(deg,
std::numeric_limits<Number>::max());
- const auto & coeffs_in = coefficients;
- auto & coeffs_out = result.coefficients;
+ const auto &coeffs_in = coefficients;
+ auto &coeffs_out = result.coefficients;
for (std::size_t i = 0; i < coeffs_out.n_elements(); ++i)
{
const auto out_index = index_to_indices(i, coeffs_out.size());
template <int dim, typename Number>
TableIndices<dim + 1>
BarycentricPolynomial<dim, Number>::index_to_indices(
- const std::size_t & index,
+ const std::size_t &index,
const TableIndices<dim + 1> &extent)
{
TableIndices<dim + 1> result;
* the first case, the function will not compute these values.
*/
void
- evaluate(const Point<dim> & unit_point,
+ evaluate(const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
* the first case, the function will not compute these values.
*/
void
- evaluate(const Point<dim> & unit_point,
+ evaluate(const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
* the first case, the function will not compute these values.
*/
void
- evaluate(const Point<dim> & unit_point,
+ evaluate(const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
void
value(const number x,
const unsigned int n_derivatives,
- number * values) const;
+ number *values) const;
/**
* Degree of the polynomial. This is the degree of the underlying base
* @note Currently, only the vectors @p values and @p grads are filled.
*/
void
- evaluate(const Point<dim> & unit_point,
- std::vector<double> & values,
+ evaluate(const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
Tensor<1, dim>
compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
Tensor<2, dim>
compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
*/
Tensor<3, dim>
compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_4th_derivative()
*/
Tensor<4, dim>
compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_grad()
Tensor<order, dim>
ScalarLagrangePolynomialPyramid<dim>::compute_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
Tensor<order, dim> der;
*/
virtual Tensor<1, dim>
compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
*/
virtual Tensor<2, dim>
compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
*/
virtual Tensor<3, dim>
compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_4th_derivative()
*/
virtual Tensor<4, dim>
compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* Gradient of basis function @p i at @p p.
* zero. A size of zero means that we are not computing the vector entries.
*/
void
- evaluate(const Point<dim> & unit_point,
- std::vector<double> & values,
+ evaluate(const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
template <int order>
Tensor<order, dim>
PolynomialsRannacherTurek<dim>::compute_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return internal::PolynomialsRannacherTurekImplementation::compute_derivative<
order>(i, p);
inline Tensor<1, dim>
PolynomialsRannacherTurek<dim>::compute_1st_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<1>(i, p);
}
inline Tensor<2, dim>
PolynomialsRannacherTurek<dim>::compute_2nd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<2>(i, p);
}
inline Tensor<3, dim>
PolynomialsRannacherTurek<dim>::compute_3rd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<3>(i, p);
}
inline Tensor<4, dim>
PolynomialsRannacherTurek<dim>::compute_4th_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<4>(i, p);
}
* the first case, the function will not compute these values.
*/
void
- evaluate(const Point<dim> & unit_point,
+ evaluate(const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
* the first case, the function will not compute these values.
*/
void
- evaluate(const Point<dim> & unit_point,
+ evaluate(const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
* @note Currently, only the vectors @p values and @p grads are filled.
*/
void
- evaluate(const Point<dim> & unit_point,
- std::vector<double> & values,
+ evaluate(const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
Tensor<1, dim>
compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
*/
Tensor<2, dim>
compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
*/
Tensor<3, dim>
compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_4th_derivative()
*/
Tensor<4, dim>
compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_grad()
Tensor<order, dim>
ScalarLagrangePolynomialWedge<dim>::compute_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
Tensor<order, dim> der;
* doc for this class.
*/
static void
- project_to_face(const ReferenceCell & reference_cell,
- const SubQuadrature & quadrature,
+ project_to_face(const ReferenceCell &reference_cell,
+ const SubQuadrature &quadrature,
const unsigned int face_no,
std::vector<Point<dim>> &q_points);
* same as those of the original rule.
*/
static void
- project_to_subface(const ReferenceCell & reference_cell,
- const SubQuadrature & quadrature,
+ project_to_subface(const ReferenceCell &reference_cell,
+ const SubQuadrature &quadrature,
const unsigned int face_no,
const unsigned int subface_no,
- std::vector<Point<dim>> & q_points,
+ std::vector<Point<dim>> &q_points,
const RefinementCase<dim - 1> &ref_case =
RefinementCase<dim - 1>::isotropic_refinement);
* version of this function that takes the reference cell type instead.
*/
static Quadrature<dim>
- project_to_subface(const ReferenceCell & reference_cell,
- const SubQuadrature & quadrature,
+ project_to_subface(const ReferenceCell &reference_cell,
+ const SubQuadrature &quadrature,
const unsigned int face_no,
const unsigned int subface_no,
const RefinementCase<dim - 1> &ref_case =
* same as those of the original rule.
*/
static Quadrature<dim>
- project_to_oriented_subface(const ReferenceCell & reference_cell,
- const SubQuadrature & quadrature,
+ project_to_oriented_subface(const ReferenceCell &reference_cell,
+ const SubQuadrature &quadrature,
const unsigned int face_no,
const unsigned int subface_no,
const bool face_orientation,
* each face, in order to cope possibly different orientations of the mesh.
*/
static Quadrature<dim>
- project_to_all_faces(const ReferenceCell & reference_cell,
+ project_to_all_faces(const ReferenceCell &reference_cell,
const hp::QCollection<dim - 1> &quadrature);
/**
* formula on all faces.
*/
static Quadrature<dim>
- project_to_all_faces(const ReferenceCell & reference_cell,
+ project_to_all_faces(const ReferenceCell &reference_cell,
const Quadrature<dim - 1> &quadrature);
/**
* GeometryInfo<dim>::children_per_cell.
*/
static Quadrature<dim>
- project_to_child(const ReferenceCell & reference_cell,
+ project_to_child(const ReferenceCell &reference_cell,
const Quadrature<dim> &quadrature,
const unsigned int child_no);
* refinement of the cell.
*/
static Quadrature<dim>
- project_to_all_children(const ReferenceCell & reference_cell,
+ project_to_all_children(const ReferenceCell &reference_cell,
const Quadrature<dim> &quadrature);
/**
static Quadrature<dim>
project_to_line(const ReferenceCell &reference_cell,
const Quadrature<1> &quadrature,
- const Point<dim> & p1,
- const Point<dim> & p2);
+ const Point<dim> &p1,
+ const Point<dim> &p2);
/**
* Since the project_to_all_faces() and project_to_all_subfaces() functions
* that each face might have different number of quadrature points.
*/
static DataSetDescriptor
- face(const ReferenceCell & reference_cell,
+ face(const ReferenceCell &reference_cell,
const unsigned int face_no,
const bool face_orientation,
const bool face_flip,
* Through the last argument anisotropic refinement can be respected.
*/
static DataSetDescriptor
- subface(const ReferenceCell & reference_cell,
+ subface(const ReferenceCell &reference_cell,
const unsigned int face_no,
const unsigned int subface_no,
const bool face_orientation,
template <int dim>
Quadrature<dim> inline QProjector<dim>::project_to_all_faces(
- const ReferenceCell & reference_cell,
+ const ReferenceCell &reference_cell,
const Quadrature<dim - 1> &quadrature)
{
return project_to_all_faces(reference_cell,
std::vector<Point<1>> &);
template <>
void
-QProjector<2>::project_to_face(const ReferenceCell & reference_cell,
- const Quadrature<1> & quadrature,
+QProjector<2>::project_to_face(const ReferenceCell &reference_cell,
+ const Quadrature<1> &quadrature,
const unsigned int face_no,
std::vector<Point<2>> &q_points);
template <>
void
-QProjector<3>::project_to_face(const ReferenceCell & reference_cell,
- const Quadrature<2> & quadrature,
+QProjector<3>::project_to_face(const ReferenceCell &reference_cell,
+ const Quadrature<2> &quadrature,
const unsigned int face_no,
std::vector<Point<3>> &q_points);
template <>
Quadrature<1>
-QProjector<1>::project_to_all_faces(const ReferenceCell & reference_cell,
+QProjector<1>::project_to_all_faces(const ReferenceCell &reference_cell,
const hp::QCollection<0> &quadrature);
const RefinementCase<0> &);
template <>
void
-QProjector<2>::project_to_subface(const ReferenceCell & reference_cell,
- const Quadrature<1> & quadrature,
+QProjector<2>::project_to_subface(const ReferenceCell &reference_cell,
+ const Quadrature<1> &quadrature,
const unsigned int face_no,
const unsigned int subface_no,
std::vector<Point<2>> &q_points,
const RefinementCase<1> &);
template <>
void
-QProjector<3>::project_to_subface(const ReferenceCell & reference_cell,
- const Quadrature<2> & quadrature,
+QProjector<3>::project_to_subface(const ReferenceCell &reference_cell,
+ const Quadrature<2> &quadrature,
const unsigned int face_no,
const unsigned int subface_no,
- std::vector<Point<3>> & q_points,
+ std::vector<Point<3>> &q_points,
const RefinementCase<2> &face_ref_case);
template <>
* You will want to have the weights sum up to one, but this is not checked.
*/
Quadrature(const std::vector<Point<dim>> &points,
- const std::vector<double> & weights);
+ const std::vector<double> &weights);
/**
* Construct a quadrature formula from given vectors of quadrature points
*/
void
initialize(const std::vector<Point<dim>> &points,
- const std::vector<double> & weights);
+ const std::vector<double> &weights);
/**
* Number of quadrature points.
*
* @note We require that `intervals.front() == 0` and `interval.back() == 1`.
*/
- QIterated(const Quadrature<1> & base_quadrature,
+ QIterated(const Quadrature<1> &base_quadrature,
const std::vector<Point<1>> &intervals);
/**
* formula or it is factored out, to be included in the integrand.
*/
QGaussLogR(const unsigned int n,
- const Point<dim> & x0 = Point<dim>(),
+ const Point<dim> &x0 = Point<dim>(),
const double alpha = 1,
const bool factor_out_singular_weight = false);
* @endcode
*/
QGaussOneOverR(const unsigned int n,
- const Point<dim> & singularity,
+ const Point<dim> &singularity,
const bool factor_out_singular_weight = false);
/**
* The constructor takes three arguments: the order of the Gauss formula,
QGaussLog<1>::QGaussLog(const unsigned int n, const bool revert);
template <>
QGaussLogR<1>::QGaussLogR(const unsigned int n,
- const Point<1> & x0,
+ const Point<1> &x0,
const double alpha,
const bool flag);
template <>
const bool flag);
template <>
QTelles<1>::QTelles(const Quadrature<1> &base_quad,
- const Point<1> & singularity);
+ const Point<1> &singularity);
#endif // DOXYGEN
*/
void
prepare_for_coarsening_and_refinement(
- parallel::distributed::Triangulation<dim> & tria,
+ parallel::distributed::Triangulation<dim> &tria,
CellDataStorage<CellIteratorType, DataType> &data_storage);
/**
std::vector<char>
pack_function(
const typename parallel::distributed::Triangulation<dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status);
/**
void
unpack_function(
const typename parallel::distributed::Triangulation<dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator>
&data_range);
*/
template <typename CellIteratorType, typename DataType>
inline void
-pack_cell_data(const CellIteratorType & cell,
+pack_cell_data(const CellIteratorType &cell,
const CellDataStorage<CellIteratorType, DataType> *data_storage,
- FullMatrix<double> & matrix_data)
+ FullMatrix<double> &matrix_data)
{
static_assert(std::is_base_of_v<TransferableQuadraturePointData, DataType>,
"User's DataType class should be derived from QPData");
*/
template <typename CellIteratorType, typename DataType>
inline void
-unpack_to_cell_data(const CellIteratorType & cell,
- const FullMatrix<double> & values_at_qp,
+unpack_to_cell_data(const CellIteratorType &cell,
+ const FullMatrix<double> &values_at_qp,
CellDataStorage<CellIteratorType, DataType> *data_storage)
{
static_assert(std::is_base_of_v<TransferableQuadraturePointData, DataType>,
template <int dim, typename DataType>
inline ContinuousQuadratureDataTransfer<dim, DataType>::
ContinuousQuadratureDataTransfer(const FiniteElement<dim> &projection_fe_,
- const Quadrature<dim> & lhs_quadrature,
- const Quadrature<dim> & rhs_quadrature)
+ const Quadrature<dim> &lhs_quadrature,
+ const Quadrature<dim> &rhs_quadrature)
: projection_fe(
std::unique_ptr<const FiniteElement<dim>>(projection_fe_.clone()))
, data_size_in_bytes(0)
inline void
ContinuousQuadratureDataTransfer<dim, DataType>::
prepare_for_coarsening_and_refinement(
- parallel::distributed::Triangulation<dim> & tr_,
+ parallel::distributed::Triangulation<dim> &tr_,
CellDataStorage<CellIteratorType, DataType> &data_storage_)
{
Assert(data_storage == nullptr,
inline void
ContinuousQuadratureDataTransfer<dim, DataType>::unpack_function(
const typename parallel::distributed::Triangulation<dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator>
&data_range)
* in a loop over all tensor product polynomials.
*/
virtual void
- evaluate(const Point<dim> & unit_point,
- std::vector<double> & values,
+ evaluate(const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
template <int order>
inline Tensor<order, dim>
ScalarPolynomialsBase<dim>::compute_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
if (order == 1)
{
*/
void
subscribe(std::atomic<bool> *const validity,
- const std::string & identifier = "") const;
+ const std::string &identifier = "") const;
/**
* Unsubscribes a user from the object.
*/
void
unsubscribe(std::atomic<bool> *const validity,
- const std::string & identifier = "") const;
+ const std::string &identifier = "") const;
/**
* Return the present number of subscriptions to this object. This allows to
// documentation inherited from the base class
virtual Tensor<1, dim, RangeNumberType>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
// documentation inherited from the base class
virtual RangeNumberType
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
// documentation inherited from the base class
virtual SymmetricTensor<2, dim, RangeNumberType>
- hessian(const Point<dim> & p,
+ hessian(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
template <int dim, typename RangeNumberType>
SymbolicFunction<dim, RangeNumberType>::SymbolicFunction(
- const std::vector<Differentiation::SD::Expression> & functions,
+ const std::vector<Differentiation::SD::Expression> &functions,
const Tensor<1, dim, Differentiation::SD::Expression> &argument,
- const Differentiation::SD::Expression & time,
+ const Differentiation::SD::Expression &time,
const Differentiation::SD::types::substitution_map &user_substitution_map)
: Function<dim, RangeNumberType>(functions.size(), 0.0)
, user_function(functions)
template <int dim, typename RangeNumberType>
RangeNumberType
SymbolicFunction<dim, RangeNumberType>::value(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
update_values();
template <int dim, typename RangeNumberType>
Tensor<1, dim, RangeNumberType>
SymbolicFunction<dim, RangeNumberType>::gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
update_first_derivatives();
template <int dim, typename RangeNumberType>
RangeNumberType
SymbolicFunction<dim, RangeNumberType>::laplacian(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
update_second_derivatives();
template <int dim, typename RangeNumberType>
SymmetricTensor<2, dim, RangeNumberType>
SymbolicFunction<dim, RangeNumberType>::hessian(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
update_second_derivatives();
* than the mother object, avoid problems with data consistency.
*/
DEAL_II_HOST
- constexpr Accessor(tensor_type & tensor,
+ constexpr Accessor(tensor_type &tensor,
const TableIndices<rank> &previous_indices);
/**
/**
* Store the data given to the constructor.
*/
- tensor_type & tensor;
+ tensor_type &tensor;
const TableIndices<rank> previous_indices;
// Declare some other classes as friends. Make sure to work around bugs
* than the mother object, avoid problems with data consistency.
*/
DEAL_II_HOST
- constexpr Accessor(tensor_type & tensor,
+ constexpr Accessor(tensor_type &tensor,
const TableIndices<rank> &previous_indices);
/**
/**
* Store the data given to the constructor.
*/
- tensor_type & tensor;
+ tensor_type &tensor;
const TableIndices<rank> previous_indices;
// Declare some other classes as friends. Make sure to work around bugs
template <int rank_, int dim, bool constness, int P, typename Number>
DEAL_II_HOST constexpr DEAL_II_ALWAYS_INLINE
Accessor<rank_, dim, constness, P, Number>::Accessor(
- tensor_type & tensor,
+ tensor_type &tensor,
const TableIndices<rank_> &previous_indices)
: tensor(tensor)
, previous_indices(previous_indices)
template <int rank_, int dim, bool constness, typename Number>
DEAL_II_HOST constexpr DEAL_II_ALWAYS_INLINE
Accessor<rank_, dim, constness, 1, Number>::Accessor(
- tensor_type & tensor,
+ tensor_type &tensor,
const TableIndices<rank_> &previous_indices)
: tensor(tensor)
, previous_indices(previous_indices)
template <int rank_, int dim, typename Number, typename OtherNumber>
DEAL_II_HOST constexpr inline DEAL_II_ALWAYS_INLINE
SymmetricTensor<rank_, dim, typename ProductType<Number, OtherNumber>::type>
- operator+(const SymmetricTensor<rank_, dim, Number> & left,
+ operator+(const SymmetricTensor<rank_, dim, Number> &left,
const SymmetricTensor<rank_, dim, OtherNumber> &right)
{
SymmetricTensor<rank_, dim, typename ProductType<Number, OtherNumber>::type>
template <int rank_, int dim, typename Number, typename OtherNumber>
DEAL_II_HOST constexpr inline DEAL_II_ALWAYS_INLINE
SymmetricTensor<rank_, dim, typename ProductType<Number, OtherNumber>::type>
- operator-(const SymmetricTensor<rank_, dim, Number> & left,
+ operator-(const SymmetricTensor<rank_, dim, Number> &left,
const SymmetricTensor<rank_, dim, OtherNumber> &right)
{
SymmetricTensor<rank_, dim, typename ProductType<Number, OtherNumber>::type>
DEAL_II_HOST constexpr DEAL_II_ALWAYS_INLINE
Tensor<rank_, dim, typename ProductType<Number, OtherNumber>::type>
operator+(const SymmetricTensor<rank_, dim, Number> &left,
- const Tensor<rank_, dim, OtherNumber> & right)
+ const Tensor<rank_, dim, OtherNumber> &right)
{
return Tensor<rank_, dim, Number>(left) + right;
}
template <int rank_, int dim, typename Number, typename OtherNumber>
DEAL_II_HOST constexpr DEAL_II_ALWAYS_INLINE
Tensor<rank_, dim, typename ProductType<Number, OtherNumber>::type>
- operator+(const Tensor<rank_, dim, Number> & left,
+ operator+(const Tensor<rank_, dim, Number> &left,
const SymmetricTensor<rank_, dim, OtherNumber> &right)
{
return left + Tensor<rank_, dim, OtherNumber>(right);
DEAL_II_HOST constexpr DEAL_II_ALWAYS_INLINE
Tensor<rank_, dim, typename ProductType<Number, OtherNumber>::type>
operator-(const SymmetricTensor<rank_, dim, Number> &left,
- const Tensor<rank_, dim, OtherNumber> & right)
+ const Tensor<rank_, dim, OtherNumber> &right)
{
return Tensor<rank_, dim, Number>(left) - right;
}
template <int rank_, int dim, typename Number, typename OtherNumber>
DEAL_II_HOST constexpr DEAL_II_ALWAYS_INLINE
Tensor<rank_, dim, typename ProductType<Number, OtherNumber>::type>
- operator-(const Tensor<rank_, dim, Number> & left,
+ operator-(const Tensor<rank_, dim, Number> &left,
const SymmetricTensor<rank_, dim, OtherNumber> &right)
{
return left - Tensor<rank_, dim, OtherNumber>(right);
template <int dim, typename Number>
void
tridiagonalize(const dealii::SymmetricTensor<2, dim, Number> &A,
- dealii::Tensor<2, dim, Number> & Q,
- std::array<Number, dim> & d,
- std::array<Number, dim - 1> & e);
+ dealii::Tensor<2, dim, Number> &Q,
+ std::array<Number, dim> &d,
+ std::array<Number, dim - 1> &e);
typename ProductType<Number,
typename EnableIfScalar<OtherNumber>::type>::type>
operator*(const SymmetricTensor<rank_, dim, Number> &t,
- const OtherNumber & factor)
+ const OtherNumber &factor)
{
// form the product. we have to convert the two factors into the final
// type via explicit casts because, for awkward reasons, the C++
dim,
typename ProductType<OtherNumber,
typename EnableIfScalar<Number>::type>::type>
-operator*(const Number & factor,
+operator*(const Number &factor,
const SymmetricTensor<rank_, dim, OtherNumber> &t)
{
// simply forward to the other operator with switched arguments
typename ProductType<Number,
typename EnableIfScalar<OtherNumber>::type>::type>
operator/(const SymmetricTensor<rank_, dim, Number> &t,
- const OtherNumber & factor)
+ const OtherNumber &factor)
{
using product_type = typename ProductType<Number, OtherNumber>::type;
SymmetricTensor<rank_, dim, product_type> tt(t);
template <int dim, typename Number, typename OtherNumber>
DEAL_II_HOST constexpr DEAL_II_ALWAYS_INLINE
typename ProductType<Number, OtherNumber>::type
- scalar_product(const SymmetricTensor<2, dim, Number> & t1,
+ scalar_product(const SymmetricTensor<2, dim, Number> &t1,
const SymmetricTensor<2, dim, OtherNumber> &t2)
{
return (t1 * t2);
DEAL_II_HOST constexpr inline DEAL_II_ALWAYS_INLINE
typename ProductType<Number, OtherNumber>::type
scalar_product(const SymmetricTensor<2, dim, Number> &t1,
- const Tensor<2, dim, OtherNumber> & t2)
+ const Tensor<2, dim, OtherNumber> &t2)
{
typename ProductType<Number, OtherNumber>::type s = internal::NumberType<
typename ProductType<Number, OtherNumber>::type>::value(0.0);
template <int dim, typename Number, typename OtherNumber>
DEAL_II_HOST constexpr DEAL_II_ALWAYS_INLINE
typename ProductType<Number, OtherNumber>::type
- scalar_product(const Tensor<2, dim, Number> & t1,
+ scalar_product(const Tensor<2, dim, Number> &t1,
const SymmetricTensor<2, dim, OtherNumber> &t2)
{
return scalar_product(t2, t1);
DEAL_II_HOST constexpr inline DEAL_II_ALWAYS_INLINE void
double_contract(
SymmetricTensor<2, 1, typename ProductType<Number, OtherNumber>::type> &tmp,
- const SymmetricTensor<4, 1, Number> & t,
- const SymmetricTensor<2, 1, OtherNumber> & s)
+ const SymmetricTensor<4, 1, Number> &t,
+ const SymmetricTensor<2, 1, OtherNumber> &s)
{
tmp[0][0] = t[0][0][0][0] * s[0][0];
}
DEAL_II_HOST constexpr inline void
double_contract(
SymmetricTensor<2, 1, typename ProductType<Number, OtherNumber>::type> &tmp,
- const SymmetricTensor<2, 1, Number> & s,
- const SymmetricTensor<4, 1, OtherNumber> & t)
+ const SymmetricTensor<2, 1, Number> &s,
+ const SymmetricTensor<4, 1, OtherNumber> &t)
{
tmp[0][0] = t[0][0][0][0] * s[0][0];
}
DEAL_II_HOST constexpr inline void
double_contract(
SymmetricTensor<2, 2, typename ProductType<Number, OtherNumber>::type> &tmp,
- const SymmetricTensor<4, 2, Number> & t,
- const SymmetricTensor<2, 2, OtherNumber> & s)
+ const SymmetricTensor<4, 2, Number> &t,
+ const SymmetricTensor<2, 2, OtherNumber> &s)
{
const unsigned int dim = 2;
DEAL_II_HOST constexpr inline void
double_contract(
SymmetricTensor<2, 2, typename ProductType<Number, OtherNumber>::type> &tmp,
- const SymmetricTensor<2, 2, Number> & s,
- const SymmetricTensor<4, 2, OtherNumber> & t)
+ const SymmetricTensor<2, 2, Number> &s,
+ const SymmetricTensor<4, 2, OtherNumber> &t)
{
const unsigned int dim = 2;
DEAL_II_HOST constexpr inline void
double_contract(
SymmetricTensor<2, 3, typename ProductType<Number, OtherNumber>::type> &tmp,
- const SymmetricTensor<4, 3, Number> & t,
- const SymmetricTensor<2, 3, OtherNumber> & s)
+ const SymmetricTensor<4, 3, Number> &t,
+ const SymmetricTensor<2, 3, OtherNumber> &s)
{
const unsigned int dim = 3;
DEAL_II_HOST constexpr inline void
double_contract(
SymmetricTensor<2, 3, typename ProductType<Number, OtherNumber>::type> &tmp,
- const SymmetricTensor<2, 3, Number> & s,
- const SymmetricTensor<4, 3, OtherNumber> & t)
+ const SymmetricTensor<2, 3, Number> &s,
+ const SymmetricTensor<4, 3, OtherNumber> &t)
{
const unsigned int dim = 3;
dim,
typename ProductType<Number, OtherNumber>::type>
operator*(const SymmetricTensor<2, dim, Number> &src1,
- const Tensor<1, dim, OtherNumber> & src2)
+ const Tensor<1, dim, OtherNumber> &src2)
{
Tensor<1, dim, typename ProductType<Number, OtherNumber>::type> dest;
for (unsigned int i = 0; i < dim; ++i)
DEAL_II_HOST constexpr Tensor<1,
dim,
typename ProductType<Number, OtherNumber>::type>
-operator*(const Tensor<1, dim, Number> & src1,
+operator*(const Tensor<1, dim, Number> &src1,
const SymmetricTensor<2, dim, OtherNumber> &src2)
{
// this is easy for symmetric tensors:
typename Tensor<rank_1 + rank_2 - 2,
dim,
typename ProductType<Number, OtherNumber>::type>::tensor_type
- operator*(const Tensor<rank_1, dim, Number> & src1,
+ operator*(const Tensor<rank_1, dim, Number> &src1,
const SymmetricTensor<rank_2, dim, OtherNumber> &src2)
{
return src1 * Tensor<rank_2, dim, OtherNumber>(src2);
dim,
typename ProductType<Number, OtherNumber>::type>::tensor_type
operator*(const SymmetricTensor<rank_1, dim, Number> &src1,
- const Tensor<rank_2, dim, OtherNumber> & src2)
+ const Tensor<rank_2, dim, OtherNumber> &src2)
{
return Tensor<rank_1, dim, Number>(src1) * src2;
}
template <int dim, typename Number>
void
tridiagonalize(const dealii::SymmetricTensor<2, dim, Number> &A,
- dealii::Tensor<2, dim, Number> & Q,
- std::array<Number, dim> & d,
- std::array<Number, dim - 1> & e)
+ dealii::Tensor<2, dim, Number> &Q,
+ std::array<Number, dim> &d,
+ std::array<Number, dim - 1> &e)
{
// Make things work with AD types
using std::sqrt;
template <bool OtherConstness>
friend bool
operator==(
- const AccessorBase<TableType, Constness, storage_order> & left,
+ const AccessorBase<TableType, Constness, storage_order> &left,
const AccessorBase<TableType, OtherConstness, storage_order> &right)
{
return left.container == right.container &&
* the description of TextOutputFormat for more information.
*/
void
- write_text(std::ostream & out,
+ write_text(std::ostream &out,
const TextOutputFormat format = table_with_headers) const;
/**
{
const int p = std::get<int>(value);
char c = 'i';
- ar &c &p;
+ ar &c &p;
}
else if (std::holds_alternative<unsigned int>(value))
{
const unsigned int p = std::get<unsigned int>(value);
char c = 'u';
- ar &c &p;
+ ar &c &p;
}
else if (std::holds_alternative<double>(value))
{
const double p = std::get<double>(value);
char c = 'd';
- ar &c &p;
+ ar &c &p;
}
else if (std::holds_alternative<std::string>(value))
{
const std::string p = std::get<std::string>(value);
char c = 's';
- ar &c &p;
+ ar &c &p;
}
else if (std::holds_alternative<std::uint64_t>(value))
{
const std::uint64_t p = std::get<std::uint64_t>(value);
char c = 'l';
- ar &c &p;
+ ar &c &p;
}
else
Assert(false, ExcInternalError());
// as a one-character id, and then read
// the data
char c;
- ar & c;
+ ar &c;
switch (c)
{
case 'u':
{
unsigned int val;
- ar & val;
+ ar &val;
value = val;
break;
}
case 'd':
{
double val;
- ar & val;
+ ar &val;
value = val;
break;
}
case 's':
{
std::string val;
- ar & val;
+ ar &val;
value = val;
break;
}
case 'l':
{
std::uint64_t val;
- ar & val;
+ ar &val;
value = val;
break;
}
* example, on class Triangulation.
*/
template <int dim, int spacedim>
- concept is_valid_dim_spacedim = (dim >= 1 && spacedim <= 3 &&
- dim <= spacedim);
+ concept is_valid_dim_spacedim =
+ (dim >= 1 && spacedim <= 3 && dim <= spacedim);
namespace internal
{
* not.
*/
template <typename VectorType>
- concept is_writable_dealii_vector_type = is_dealii_vector_type<VectorType> &&
- (std::is_const_v<VectorType> ==
- false);
+ concept is_writable_dealii_vector_type =
+ is_dealii_vector_type<VectorType> && (std::is_const_v<VectorType> == false);
/**
* A concept that tests whether a given template argument is a deal.II
VectorType W,
typename VectorType::value_type a,
typename VectorType::value_type b,
- typename VectorType::value_type s)
- {
+ typename VectorType::value_type s) {
// Check local type requirements:
typename VectorType::value_type;
typename VectorType::size_type;
// Norms and similar stuff:
{
U.mean_value()
- }
- ->std::convertible_to<typename VectorType::value_type>;
+ } -> std::convertible_to<typename VectorType::value_type>;
{
U.l1_norm()
- }
- ->std::convertible_to<typename VectorType::real_type>;
+ } -> std::convertible_to<typename VectorType::real_type>;
{
U.l2_norm()
- }
- ->std::convertible_to<typename VectorType::real_type>;
+ } -> std::convertible_to<typename VectorType::real_type>;
{
U.linfty_norm()
- }
- ->std::convertible_to<typename VectorType::real_type>;
+ } -> std::convertible_to<typename VectorType::real_type>;
// Dot products:
{
U *V
- }
- ->std::convertible_to<typename VectorType::value_type>;
+ } -> std::convertible_to<typename VectorType::value_type>;
{
U.add_and_dot(a, V, W)
- }
- ->std::convertible_to<typename VectorType::value_type>;
+ } -> std::convertible_to<typename VectorType::value_type>;
// Some queries:
{
U.size()
- }
- ->std::convertible_to<typename VectorType::size_type>;
+ } -> std::convertible_to<typename VectorType::size_type>;
{
U.all_zero()
- }
- ->std::same_as<bool>;
+ } -> std::same_as<bool>;
};
#endif
* @note This function can also be used in @ref GlossDevice "device" code.
*/
constexpr DEAL_II_HOST_DEVICE Tensor &
- operator=(const Tensor<0, dim, Number> &rhs);
+ operator=(const Tensor<0, dim, Number> &rhs);
#endif
#ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
*/
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE Tensor &
- operator=(const OtherNumber &d) &;
+ operator=(const OtherNumber &d) &;
/**
* Assign a scalar to the current object. This overload is used for
*/
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE Tensor &
- operator=(const OtherNumber &d) && = delete;
+ operator=(const OtherNumber &d) && = delete;
/**
* Test for equality of two tensors.
*/
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE Tensor &
- operator*=(const OtherNumber &factor);
+ operator*=(const OtherNumber &factor);
/**
* Divide the scalar by <tt>factor</tt>.
*/
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE Tensor &
- operator/=(const OtherNumber &factor);
+ operator/=(const OtherNumber &factor);
/**
* Tensor with inverted entries.
* @note This function can also be used in @ref GlossDevice "device" code.
*/
constexpr DEAL_II_HOST_DEVICE value_type &
- operator[](const unsigned int i);
+ operator[](const unsigned int i);
/**
* Read-only access operator.
* @note This function can also be used in @ref GlossDevice "device" code.
*/
constexpr DEAL_II_HOST_DEVICE const value_type &
- operator[](const unsigned int i) const;
+ operator[](const unsigned int i) const;
/**
* Read access using TableIndices <tt>indices</tt>
* <tt>t=0</tt> to reset all elements of the tensor to zero.
*/
constexpr DEAL_II_HOST_DEVICE Tensor &
- operator=(const Number &d) &;
+ operator=(const Number &d) &;
/**
* Assign a scalar to the current object. This overload is used for
* something to a temporary, the function is deleted.
*/
constexpr DEAL_II_HOST_DEVICE Tensor &
- operator=(const Number &d) && = delete;
+ operator=(const Number &d) && = delete;
#ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
/**
*/
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE Tensor &
- operator*=(const OtherNumber &factor);
+ operator*=(const OtherNumber &factor);
/**
* Scale the vector by <tt>1/factor</tt>.
*/
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE Tensor &
- operator/=(const OtherNumber &factor);
+ operator/=(const OtherNumber &factor);
/**
* Unary minus operator. Negate all entries of a tensor.
{
template <typename ArrayElementType, int dim>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE ArrayElementType &
- subscript(ArrayElementType * values,
+ subscript(ArrayElementType *values,
const unsigned int i,
std::integral_constant<int, dim>)
{
template <int rank_, int dim, typename Number>
-constexpr DEAL_II_ALWAYS_INLINE Tensor<rank_, dim, Number> &
+constexpr DEAL_II_ALWAYS_INLINE Tensor<rank_, dim, Number> &
Tensor<rank_, dim, Number>::operator=(
Tensor<rank_, dim, Number> &&other) noexcept
{
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
- DEAL_II_HOST_DEVICE Tensor<rank_, dim, Number> &
+ DEAL_II_HOST_DEVICE Tensor<rank_, dim, Number> &
Tensor<rank_, dim, Number>::operator+=(
const Tensor<rank_, dim, OtherNumber> &p)
{
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
- DEAL_II_HOST_DEVICE Tensor<rank_, dim, Number> &
+ DEAL_II_HOST_DEVICE Tensor<rank_, dim, Number> &
Tensor<rank_, dim, Number>::operator-=(
const Tensor<rank_, dim, OtherNumber> &p)
{
template <int rank_, int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE
DEAL_II_HOST_DEVICE Tensor<rank_, dim, Number>
- Tensor<rank_, dim, Number>::operator-() const
+ Tensor<rank_, dim, Number>::operator-() const
{
Tensor<rank_, dim, Number> tmp;
template <int dim, typename Number, typename OtherNumber>
DEAL_II_HOST_DEVICE constexpr DEAL_II_ALWAYS_INLINE
typename ProductType<Number, OtherNumber>::type
- operator*(const Tensor<0, dim, Number> & src1,
+ operator*(const Tensor<0, dim, Number> &src1,
const Tensor<0, dim, OtherNumber> &src2)
{
return static_cast<const Number &>(src1) *
template <int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<0, dim, typename ProductType<Number, OtherNumber>::type>
- operator+(const Tensor<0, dim, Number> & p,
+ operator+(const Tensor<0, dim, Number> &p,
const Tensor<0, dim, OtherNumber> &q)
{
return static_cast<const Number &>(p) + static_cast<const OtherNumber &>(q);
template <int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<0, dim, typename ProductType<Number, OtherNumber>::type>
- operator-(const Tensor<0, dim, Number> & p,
+ operator-(const Tensor<0, dim, Number> &p,
const Tensor<0, dim, OtherNumber> &q)
{
return static_cast<const Number &>(p) - static_cast<const OtherNumber &>(q);
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type>
division_operator(const Tensor<rank, dim, Number> &t,
- const OtherNumber & factor)
+ const OtherNumber &factor)
{
Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type> tt;
const Number inverse_factor = Number(1.) / factor;
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type>
division_operator(const Tensor<rank, dim, Number> &t,
- const OtherNumber & factor)
+ const OtherNumber &factor)
{
Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type> tt;
// recurse over the base objects
template <int rank, int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type>
- operator+(const Tensor<rank, dim, Number> & p,
+ operator+(const Tensor<rank, dim, Number> &p,
const Tensor<rank, dim, OtherNumber> &q)
{
Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type> tmp(p);
template <int rank, int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type>
- operator-(const Tensor<rank, dim, Number> & p,
+ operator-(const Tensor<rank, dim, Number> &p,
const Tensor<rank, dim, OtherNumber> &q)
{
Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type> tmp(p);
template <int dim, typename Number, typename OtherNumber>
inline constexpr DEAL_II_ALWAYS_INLINE
Tensor<0, dim, typename ProductType<Number, OtherNumber>::type>
- schur_product(const Tensor<0, dim, Number> & src1,
+ schur_product(const Tensor<0, dim, Number> &src1,
const Tensor<0, dim, OtherNumber> &src2)
{
Tensor<0, dim, typename ProductType<Number, OtherNumber>::type> tmp(src1);
template <int rank, int dim, typename Number, typename OtherNumber>
inline constexpr DEAL_II_ALWAYS_INLINE
Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type>
- schur_product(const Tensor<rank, dim, Number> & src1,
+ schur_product(const Tensor<rank, dim, Number> &src1,
const Tensor<rank, dim, OtherNumber> &src2)
{
Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type> tmp;
typename Tensor<rank_1 + rank_2 - 2,
dim,
typename ProductType<Number, OtherNumber>::type>::tensor_type
- operator*(const Tensor<rank_1, dim, Number> & src1,
+ operator*(const Tensor<rank_1, dim, Number> &src1,
const Tensor<rank_2, dim, OtherNumber> &src2)
{
typename Tensor<rank_1 + rank_2 - 2,
typename Tensor<rank_1 + rank_2 - 2,
dim,
typename ProductType<Number, OtherNumber>::type>::tensor_type
- contract(const Tensor<rank_1, dim, Number> & src1,
+ contract(const Tensor<rank_1, dim, Number> &src1,
const Tensor<rank_2, dim, OtherNumber> &src2)
{
Assert(0 <= index_1 && index_1 < rank_1,
typename Tensor<rank_1 + rank_2 - 4,
dim,
typename ProductType<Number, OtherNumber>::type>::tensor_type
- double_contract(const Tensor<rank_1, dim, Number> & src1,
+ double_contract(const Tensor<rank_1, dim, Number> &src1,
const Tensor<rank_2, dim, OtherNumber> &src2)
{
Assert(0 <= index_1 && index_1 < rank_1,
template <int rank, int dim, typename Number, typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
typename ProductType<Number, OtherNumber>::type
- scalar_product(const Tensor<rank, dim, Number> & left,
+ scalar_product(const Tensor<rank, dim, Number> &left,
const Tensor<rank, dim, OtherNumber> &right)
{
typename ProductType<Number, OtherNumber>::type result{};
typename T3>
constexpr inline DEAL_II_ALWAYS_INLINE
typename ProductType<T1, typename ProductType<T2, T3>::type>::type
- contract3(const TensorT1<rank_1, dim, T1> & left,
+ contract3(const TensorT1<rank_1, dim, T1> &left,
const TensorT2<rank_1 + rank_2, dim, T2> &middle,
- const TensorT3<rank_2, dim, T3> & right)
+ const TensorT3<rank_2, dim, T3> &right)
{
using return_type =
typename ProductType<T1, typename ProductType<T2, T3>::type>::type;
typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
Tensor<rank_1 + rank_2, dim, typename ProductType<Number, OtherNumber>::type>
- outer_product(const Tensor<rank_1, dim, Number> & src1,
+ outer_product(const Tensor<rank_1, dim, Number> &src1,
const Tensor<rank_2, dim, OtherNumber> &src2)
{
typename Tensor<rank_1 + rank_2,
using value_type = return_type;
constexpr DEAL_II_ALWAYS_INLINE return_type &
- operator[](unsigned int j) const
+ operator[](unsigned int j) const
{
return s_.apply(j)[i_];
}
*/
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<value_type> & values) const;
+ std::vector<value_type> &values) const;
/**
* Return the gradient of the function at the given point.
*/
virtual void
gradient_list(const std::vector<Point<dim>> &points,
- std::vector<gradient_type> & gradients) const;
+ std::vector<gradient_type> &gradients) const;
};
void
TensorFunction<rank, dim, Number>::value_list(
const std::vector<Point<dim>> &points,
- std::vector<value_type> & values) const
+ std::vector<value_type> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
void
TensorFunction<rank, dim, Number>::gradient_list(
const std::vector<Point<dim>> &points,
- std::vector<gradient_type> & gradients) const
+ std::vector<gradient_type> &gradients) const
{
Assert(gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
template <int rank, int dim, typename Number>
void
ConstantTensorFunction<rank, dim, Number>::value_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<typename TensorFunction<rank, dim, Number>::value_type> &values)
const
{
* false, i.e. do not consider time.
*/
virtual void
- initialize(const std::string & vars,
+ initialize(const std::string &vars,
const std::vector<std::string> &expressions,
- const ConstMap & constants,
+ const ConstMap &constants,
const bool time_dependent = false) override;
/**
void
initialize(const std::string &vars,
const std::string &expression,
- const ConstMap & constants,
+ const ConstMap &constants,
const bool time_dependent = false);
/**
* Return the value of the tensor function at the given point.
*/
virtual void
- value_list(const std::vector<Point<dim>> & p,
+ value_list(const std::vector<Point<dim>> &p,
std::vector<Tensor<rank, dim, Number>> &values) const override;
/**
* the first case, the function will not compute these values.
*/
virtual void
- evaluate(const Point<dim> & unit_point,
+ evaluate(const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
* over all tensor product polynomials.
*/
void
- evaluate(const Point<dim> & unit_point,
- std::vector<double> & values,
+ evaluate(const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
*/
virtual Tensor<1, dim>
compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
*/
virtual Tensor<2, dim>
compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
*/
virtual Tensor<3, dim>
compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_4th_derivative()
*/
virtual Tensor<4, dim>
compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* Compute the grad of the <tt>i</tt>th tensor product polynomial at
* in a loop over all tensor product polynomials.
*/
void
- evaluate(const Point<dim> & unit_point,
- std::vector<double> & values,
+ evaluate(const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
*/
virtual Tensor<1, dim>
compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
*/
virtual Tensor<2, dim>
compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
*/
virtual Tensor<3, dim>
compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_4th_derivative()
*/
virtual Tensor<4, dim>
compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* Compute the grad of the <tt>i</tt>th tensor product polynomial at
Tensor<order, dim>
TensorProductPolynomials<dim, PolynomialType>::compute_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
std::array<unsigned int, dim> indices;
compute_index(i, indices);
inline Tensor<1, dim>
TensorProductPolynomials<dim, PolynomialType>::compute_1st_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<1>(i, p);
}
inline Tensor<2, dim>
TensorProductPolynomials<dim, PolynomialType>::compute_2nd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<2>(i, p);
}
inline Tensor<3, dim>
TensorProductPolynomials<dim, PolynomialType>::compute_3rd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<3>(i, p);
}
inline Tensor<4, dim>
TensorProductPolynomials<dim, PolynomialType>::compute_4th_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<4>(i, p);
}
template <int order>
Tensor<order, dim>
AnisotropicPolynomials<dim>::compute_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
std::array<unsigned int, dim> indices;
compute_index(i, indices);
template <int dim>
inline Tensor<1, dim>
AnisotropicPolynomials<dim>::compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<1>(i, p);
}
template <int dim>
inline Tensor<2, dim>
AnisotropicPolynomials<dim>::compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<2>(i, p);
}
template <int dim>
inline Tensor<3, dim>
AnisotropicPolynomials<dim>::compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<3>(i, p);
}
template <int dim>
inline Tensor<4, dim>
AnisotropicPolynomials<dim>::compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<4>(i, p);
}
* over all tensor product polynomials.
*/
void
- evaluate(const Point<dim> & unit_point,
- std::vector<double> & values,
+ evaluate(const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
*/
virtual Tensor<1, dim>
compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
*/
virtual Tensor<2, dim>
compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
*/
virtual Tensor<3, dim>
compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_4th_derivative()
*/
virtual Tensor<4, dim>
compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* Compute the grad of the <tt>i</tt>th tensor product polynomial at
Tensor<order, dim>
TensorProductPolynomialsBubbles<dim>::compute_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const unsigned int q_degree = tensor_polys.polynomials.size() - 1;
const unsigned int max_q_indices = tensor_polys.n();
inline Tensor<1, dim>
TensorProductPolynomialsBubbles<dim>::compute_1st_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<1>(i, p);
}
inline Tensor<2, dim>
TensorProductPolynomialsBubbles<dim>::compute_2nd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<2>(i, p);
}
inline Tensor<3, dim>
TensorProductPolynomialsBubbles<dim>::compute_3rd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<3>(i, p);
}
inline Tensor<4, dim>
TensorProductPolynomialsBubbles<dim>::compute_4th_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<4>(i, p);
}
* over all tensor product polynomials.
*/
void
- evaluate(const Point<dim> & unit_point,
- std::vector<double> & values,
+ evaluate(const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
*/
virtual Tensor<1, dim>
compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
*/
virtual Tensor<2, dim>
compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
*/
virtual Tensor<3, dim>
compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* @copydoc ScalarPolynomialsBase::compute_4th_derivative()
*/
virtual Tensor<4, dim>
compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* Compute the grad of the <tt>i</tt>th tensor product polynomial at
Tensor<order, dim>
TensorProductPolynomialsConst<dim>::compute_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const unsigned int max_indices = tensor_polys.n();
Assert(i <= max_indices, ExcInternalError());
inline Tensor<1, dim>
TensorProductPolynomialsConst<dim>::compute_1st_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<1>(i, p);
}
inline Tensor<2, dim>
TensorProductPolynomialsConst<dim>::compute_2nd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<2>(i, p);
}
inline Tensor<3, dim>
TensorProductPolynomialsConst<dim>::compute_3rd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<3>(i, p);
}
inline Tensor<4, dim>
TensorProductPolynomialsConst<dim>::compute_4th_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_derivative<4>(i, p);
}
std::enable_if_t<
std::is_copy_constructible_v<typename unpack_container<T>::type>,
T &>
- construct_element(std::map<std::thread::id, T> & data,
- const std::thread::id & id,
+ construct_element(std::map<std::thread::id, T> &data,
+ const std::thread::id &id,
const std::shared_ptr<const T> &exemplar)
{
if (exemplar)
!std::is_copy_constructible_v<typename unpack_container<T>::type>,
T &>
construct_element(std::map<std::thread::id, T> &data,
- const std::thread::id & id,
+ const std::thread::id &id,
const std::shared_ptr<const T> &)
{
return data[id];
struct return_value<RT &>
{
private:
- RT * value;
+ RT *value;
bool value_is_initialized;
public:
*/
template <typename Function>
DEAL_II_CXX20_REQUIRES((std::invocable<Function>))
- void evaluate_and_set_promise(Function & function,
+ void evaluate_and_set_promise(Function &function,
std::promise<void> &promise)
{
function();
virtual double
evolve_one_time_step(
std::vector<std::function<VectorType(const double, const VectorType &)>>
- & F,
+ &F,
std::vector<std::function<
VectorType(const double, const double, const VectorType &)>> &J_inverse,
double t,
double delta_t,
- VectorType & y) = 0;
+ VectorType &y) = 0;
/**
* Empty structure used to store information.
double
evolve_one_time_step(
std::vector<std::function<VectorType(const double, const VectorType &)>>
- & F,
+ &F,
std::vector<std::function<
VectorType(const double, const double, const VectorType &)>> &J_inverse,
double t,
const std::function<VectorType(const double, const VectorType &)> &f,
const std::function<
VectorType(const double, const double, const VectorType &)>
- & id_minus_tau_J_inverse,
+ &id_minus_tau_J_inverse,
double t,
double delta_t,
VectorType &y) = 0;
const std::function<VectorType(const double, const VectorType &)> &f,
const std::function<
VectorType(const double, const double, const VectorType &)>
- & id_minus_tau_J_inverse,
+ &id_minus_tau_J_inverse,
double t,
double delta_t,
VectorType &y) override;
const std::function<VectorType(const double, const VectorType &)> &f,
const double t,
const double delta_t,
- const VectorType & y,
+ const VectorType &y,
std::vector<VectorType> &f_stages) const;
/**
const std::function<VectorType(const double, const VectorType &)> &f,
const std::function<
VectorType(const double, const double, const VectorType &)>
- & id_minus_tau_J_inverse,
+ &id_minus_tau_J_inverse,
double t,
double delta_t,
VectorType &y) override;
const double factor_solution,
const double factor_ai,
const VectorType &corrent_ri,
- VectorType & vec_ki,
- VectorType & solution,
- VectorType & next_ri) const;
+ VectorType &vec_ki,
+ VectorType &solution,
+ VectorType &next_ri) const;
/**
* Status structure of the object.
const std::function<VectorType(const double, const VectorType &)> &f,
const std::function<
VectorType(const double, const double, const VectorType &)>
- & id_minus_tau_J_inverse,
+ &id_minus_tau_J_inverse,
double t,
double delta_t,
VectorType &y) override;
const std::function<VectorType(const double, const VectorType &)> &f,
const std::function<
VectorType(const double, const double, const VectorType &)>
- & id_minus_tau_J_inverse,
+ &id_minus_tau_J_inverse,
double t,
double delta_t,
- VectorType & y,
+ VectorType &y,
std::vector<VectorType> &f_stages);
/**
newton_solve(
const std::function<void(const VectorType &, VectorType &)> &get_residual,
const std::function<VectorType(const VectorType &)>
- & id_minus_tau_J_inverse,
+ &id_minus_tau_J_inverse,
VectorType &y);
/**
double delta_t,
const VectorType &new_y,
const VectorType &y,
- VectorType & tendency,
- VectorType & residual) const;
+ VectorType &tendency,
+ VectorType &residual) const;
/**
* Maximum number of iterations of the Newton solver.
const std::function<VectorType(const double, const VectorType &)> &f,
const std::function<
VectorType(const double, const double, const VectorType &)>
- & id_minus_tau_J_inverse,
+ &id_minus_tau_J_inverse,
double t,
double delta_t,
VectorType &y) override;
const std::function<VectorType(const double, const VectorType &)> &f,
const double t,
const double delta_t,
- const VectorType & y,
+ const VectorType &y,
std::vector<VectorType> &f_stages);
/**
const std::function<VectorType(const double, const VectorType &)> &f,
double t,
double delta_t,
- VectorType & y)
+ VectorType &y)
{
Assert(status.method != runge_kutta_method::invalid, ExcNoMethodSelected());
const std::function<VectorType(const double, const VectorType &)> &f,
const double t,
const double delta_t,
- const VectorType & y,
+ const VectorType &y,
std::vector<VectorType> &f_stages) const
{
for (unsigned int i = 0; i < this->n_stages; ++i)
{
this->n_stages = 5;
this->b = {{1153189308089. / 22510343858157.,
- 1772645290293. / 4653164025191.,
- -1672844663538. / 4480602732383.,
- 2114624349019. / 3568978502595.,
- 5198255086312. / 14908931495163.}};
+ 1772645290293. / 4653164025191.,
+ -1672844663538. / 4480602732383.,
+ 2114624349019. / 3568978502595.,
+ 5198255086312. / 14908931495163.}};
std::vector<double> ai;
ai = {{970286171893. / 4311952581923.,
6584761158862. / 12103376702013.,
{
this->n_stages = 7;
this->b = {{0.0941840925477795334,
- 0.149683694803496998,
- 0.285204742060440058,
- -0.122201846148053668,
- 0.0605151571191401122,
- 0.345986987898399296,
- 0.186627171718797670}};
+ 0.149683694803496998,
+ 0.285204742060440058,
+ -0.122201846148053668,
+ 0.0605151571191401122,
+ 0.345986987898399296,
+ 0.186627171718797670}};
std::vector<double> ai;
ai = {{0.241566650129646868 + this->b[0],
0.0423866513027719953 + this->b[1],
{
this->n_stages = 9;
this->b = {{2274579626619. / 23610510767302.,
- 693987741272. / 12394497460941.,
- -347131529483. / 15096185902911.,
- 1144057200723. / 32081666971178.,
- 1562491064753. / 11797114684756.,
- 13113619727965. / 44346030145118.,
- 393957816125. / 7825732611452.,
- 720647959663. / 6565743875477.,
- 3559252274877. / 14424734981077.}};
+ 693987741272. / 12394497460941.,
+ -347131529483. / 15096185902911.,
+ 1144057200723. / 32081666971178.,
+ 1562491064753. / 11797114684756.,
+ 13113619727965. / 44346030145118.,
+ 393957816125. / 7825732611452.,
+ 720647959663. / 6565743875477.,
+ 3559252274877. / 14424734981077.}};
std::vector<double> ai;
ai = {{1107026461565. / 5417078080134.,
38141181049399. / 41724347789894.,
const std::function<VectorType(const double, const VectorType &)> &f,
double t,
double delta_t,
- VectorType & solution,
- VectorType & vec_ri,
- VectorType & vec_ki)
+ VectorType &solution,
+ VectorType &vec_ri,
+ VectorType &vec_ki)
{
Assert(status.method != runge_kutta_method::invalid, ExcNoMethodSelected());
const double factor_solution,
const double factor_ai,
const VectorType ¤t_ri,
- VectorType & vec_ki,
- VectorType & solution,
- VectorType & next_ri) const
+ VectorType &vec_ki,
+ VectorType &solution,
+ VectorType &next_ri) const
{
const double ai = factor_ai;
const double bi = factor_solution;
const VectorType &)> &id_minus_tau_J_inverse,
double t,
double delta_t,
- VectorType & y)
+ VectorType &y)
{
Assert(status.method != runge_kutta_method::invalid, ExcNoMethodSelected());
const VectorType &)> &id_minus_tau_J_inverse,
double t,
double delta_t,
- VectorType & y,
- std::vector<VectorType> & f_stages)
+ VectorType &y,
+ std::vector<VectorType> &f_stages)
{
VectorType z(y);
for (unsigned int i = 0; i < this->n_stages; ++i)
// Solve the nonlinear system using Newton's method
const double new_t = t + this->c[i] * delta_t;
const double new_delta_t = this->a[i][i] * delta_t;
- VectorType & f_stage = f_stages[i];
+ VectorType &f_stage = f_stages[i];
newton_solve(
[this, &f, new_t, new_delta_t, &old_y, &f_stage](
const VectorType &y, VectorType &residual) {
ImplicitRungeKutta<VectorType>::newton_solve(
const std::function<void(const VectorType &, VectorType &)> &get_residual,
const std::function<VectorType(const VectorType &)> &id_minus_tau_J_inverse,
- VectorType & y)
+ VectorType &y)
{
VectorType residual(y);
get_residual(y, residual);
const std::function<VectorType(const double, const VectorType &)> &f,
double t,
double delta_t,
- const VectorType & old_y,
- const VectorType & y,
- VectorType & tendency,
+ const VectorType &old_y,
+ const VectorType &y,
+ VectorType &tendency,
VectorType &residual) const
{
// The tendency is stored to save one evaluation of f.
const std::function<VectorType(const double, const VectorType &)> &f,
double t,
double delta_t,
- VectorType & y)
+ VectorType &y)
{
Assert(status.method != runge_kutta_method::invalid, ExcNoMethodSelected());
const std::function<VectorType(const double, const VectorType &)> &f,
const double t,
const double delta_t,
- const VectorType & y,
- std::vector<VectorType> & f_stages)
+ const VectorType &y,
+ std::vector<VectorType> &f_stages)
{
VectorType Y(y);
unsigned int i = 0;
* @param output_type A variable indicating what kind of timing the output
* should represent (CPU or wall time).
*/
- TimerOutput(std::ostream & stream,
+ TimerOutput(std::ostream &stream,
const OutputFrequency output_frequency,
const OutputType output_type);
* @param output_type A variable indicating what kind of timing the output
* should represent (CPU or wall time).
*/
- TimerOutput(ConditionalOStream & stream,
+ TimerOutput(ConditionalOStream &stream,
const OutputFrequency output_frequency,
const OutputType output_type);
* each section.
*/
TimerOutput(const MPI_Comm mpi_comm,
- std::ostream & stream,
+ std::ostream &stream,
const OutputFrequency output_frequency,
const OutputType output_type);
* each section.)
*/
TimerOutput(const MPI_Comm mpi_comm,
- ConditionalOStream & stream,
+ ConditionalOStream &stream,
const OutputFrequency output_frequency,
const OutputType output_type);
inline TimerOutput::Scope::Scope(dealii::TimerOutput &timer_,
- const std::string & section_name_)
+ const std::string §ion_name_)
: timer(timer_)
, section_name(section_name_)
, in(true)
*/
template <typename T>
size_t
- pack(const T & object,
+ pack(const T &object,
std::vector<char> &dest_buffer,
const bool allow_compression = true);
inline void
append_vector_of_trivially_copyable_to_buffer(
const std::vector<T> &object,
- std::vector<char> & dest_buffer)
+ std::vector<char> &dest_buffer)
{
const typename std::vector<T>::size_type vector_size = object.size();
inline void
append_vector_of_trivially_copyable_to_buffer(
const std::vector<std::vector<T>> &object,
- std::vector<char> & dest_buffer)
+ std::vector<char> &dest_buffer)
{
using size_type = typename std::vector<T>::size_type;
const size_type vector_size = object.size();
create_vector_of_trivially_copyable_from_buffer(
const std::vector<char>::const_iterator &cbegin,
const std::vector<char>::const_iterator &cend,
- std::vector<T> & object)
+ std::vector<T> &object)
{
// The size of the object vector can be found in cbegin of the buffer.
// The data starts at cbegin + sizeof(vector_size).
create_vector_of_trivially_copyable_from_buffer(
const std::vector<char>::const_iterator &cbegin,
const std::vector<char>::const_iterator &cend,
- std::vector<std::vector<T>> & object)
+ std::vector<std::vector<T>> &object)
{
// First get the size of the vector, and resize the output object
using size_type = typename std::vector<T>::size_type;
template <typename T>
size_t
- pack(const T & object,
+ pack(const T &object,
std::vector<char> &dest_buffer,
const bool allow_compression)
{
*/
template <typename Number, std::size_t width>
inline DEAL_II_ALWAYS_INLINE void
-gather(VectorizedArray<Number, width> & out,
+gather(VectorizedArray<Number, width> &out,
const std::array<Number *, width> &ptrs,
const unsigned int offset)
{
template <typename Number, std::size_t width>
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
- const Number * in,
- const unsigned int * offsets,
+ const Number *in,
+ const unsigned int *offsets,
VectorizedArray<Number, width> *out)
{
for (unsigned int i = 0; i < n_entries; ++i)
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
const std::array<Number *, width> &in,
- VectorizedArray<Number, width> * out)
+ VectorizedArray<Number, width> *out)
{
for (unsigned int i = 0; i < n_entries; ++i)
for (unsigned int v = 0; v < VectorizedArray<Number, width>::size(); ++v)
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<Number, width> *in,
- const unsigned int * offsets,
- Number * out)
+ const unsigned int *offsets,
+ Number *out)
{
if (add_into)
for (unsigned int i = 0; i < n_entries; ++i)
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<Number, width> *in,
- std::array<Number *, width> & out)
+ std::array<Number *, width> &out)
{
if (add_into)
for (unsigned int i = 0; i < n_entries; ++i)
template <>
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
- const double * in,
- const unsigned int * offsets,
+ const double *in,
+ const unsigned int *offsets,
VectorizedArray<double, 2> *out)
{
const unsigned int n_chunks = n_entries / 2;
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
const std::array<double *, 2> &in,
- VectorizedArray<double, 2> * out)
+ VectorizedArray<double, 2> *out)
{
// see the comments in the vectorized_load_and_transpose above
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<double, 2> *in,
- const unsigned int * offsets,
- double * out)
+ const unsigned int *offsets,
+ double *out)
{
const unsigned int n_chunks = n_entries / 2;
if (add_into)
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<double, 2> *in,
- std::array<double *, 2> & out)
+ std::array<double *, 2> &out)
{
// see the comments in the vectorized_transpose_and_store above
template <>
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
- const float * in,
- const unsigned int * offsets,
+ const float *in,
+ const unsigned int *offsets,
VectorizedArray<float, 4> *out)
{
const unsigned int n_chunks = n_entries / 4;
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
const std::array<float *, 4> &in,
- VectorizedArray<float, 4> * out)
+ VectorizedArray<float, 4> *out)
{
// see the comments in the vectorized_load_and_transpose above
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<float, 4> *in,
- const unsigned int * offsets,
- float * out)
+ const unsigned int *offsets,
+ float *out)
{
const unsigned int n_chunks = n_entries / 4;
for (unsigned int i = 0; i < n_chunks; ++i)
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<float, 4> *in,
- std::array<float *, 4> & out)
+ std::array<float *, 4> &out)
{
// see the comments in the vectorized_transpose_and_store above
template <>
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
- const double * in,
- const unsigned int * offsets,
+ const double *in,
+ const unsigned int *offsets,
VectorizedArray<double, 4> *out)
{
const unsigned int n_chunks = n_entries / 4;
- const double * in0 = in + offsets[0];
- const double * in1 = in + offsets[1];
- const double * in2 = in + offsets[2];
- const double * in3 = in + offsets[3];
+ const double *in0 = in + offsets[0];
+ const double *in1 = in + offsets[1];
+ const double *in2 = in + offsets[2];
+ const double *in3 = in + offsets[3];
for (unsigned int i = 0; i < n_chunks; ++i)
{
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
const std::array<double *, 4> &in,
- VectorizedArray<double, 4> * out)
+ VectorizedArray<double, 4> *out)
{
// see the comments in the vectorized_load_and_transpose above
const unsigned int n_chunks = n_entries / 4;
- const double * in0 = in[0];
- const double * in1 = in[1];
- const double * in2 = in[2];
- const double * in3 = in[3];
+ const double *in0 = in[0];
+ const double *in1 = in[1];
+ const double *in2 = in[2];
+ const double *in3 = in[3];
for (unsigned int i = 0; i < n_chunks; ++i)
{
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<double, 4> *in,
- const unsigned int * offsets,
- double * out)
+ const unsigned int *offsets,
+ double *out)
{
const unsigned int n_chunks = n_entries / 4;
- double * out0 = out + offsets[0];
- double * out1 = out + offsets[1];
- double * out2 = out + offsets[2];
- double * out3 = out + offsets[3];
+ double *out0 = out + offsets[0];
+ double *out1 = out + offsets[1];
+ double *out2 = out + offsets[2];
+ double *out3 = out + offsets[3];
for (unsigned int i = 0; i < n_chunks; ++i)
{
__m256d u0 = in[4 * i + 0].data;
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<double, 4> *in,
- std::array<double *, 4> & out)
+ std::array<double *, 4> &out)
{
// see the comments in the vectorized_transpose_and_store above
const unsigned int n_chunks = n_entries / 4;
- double * out0 = out[0];
- double * out1 = out[1];
- double * out2 = out[2];
- double * out3 = out[3];
+ double *out0 = out[0];
+ double *out1 = out[1];
+ double *out2 = out[2];
+ double *out3 = out[3];
for (unsigned int i = 0; i < n_chunks; ++i)
{
__m256d u0 = in[4 * i + 0].data;
template <>
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
- const float * in,
- const unsigned int * offsets,
+ const float *in,
+ const unsigned int *offsets,
VectorizedArray<float, 8> *out)
{
const unsigned int n_chunks = n_entries / 4;
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
const std::array<float *, 8> &in,
- VectorizedArray<float, 8> * out)
+ VectorizedArray<float, 8> *out)
{
// see the comments in the vectorized_load_and_transpose above
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<float, 8> *in,
- const unsigned int * offsets,
- float * out)
+ const unsigned int *offsets,
+ float *out)
{
const unsigned int n_chunks = n_entries / 4;
for (unsigned int i = 0; i < n_chunks; ++i)
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<float, 8> *in,
- std::array<float *, 8> & out)
+ std::array<float *, 8> &out)
{
// see the comments in the vectorized_transpose_and_store above
template <>
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
- const double * in,
- const unsigned int * offsets,
+ const double *in,
+ const unsigned int *offsets,
VectorizedArray<double, 8> *out)
{
// do not do full transpose because the code is long and will most
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
const std::array<double *, 8> &in,
- VectorizedArray<double, 8> * out)
+ VectorizedArray<double, 8> *out)
{
const unsigned int n_chunks = n_entries / 4;
for (unsigned int i = 0; i < n_chunks; ++i)
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<double, 8> *in,
- const unsigned int * offsets,
- double * out)
+ const unsigned int *offsets,
+ double *out)
{
// as for the load, we split the store operations into 256 bit units to
// better balance between code size, shuffle instructions, and stores
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<double, 8> *in,
- std::array<double *, 8> & out)
+ std::array<double *, 8> &out)
{
// see the comments in the vectorized_transpose_and_store above
template <>
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
- const float * in,
- const unsigned int * offsets,
+ const float *in,
+ const unsigned int *offsets,
VectorizedArray<float, 16> *out)
{
// Similar to the double case, we perform the work on smaller entities. In
inline DEAL_II_ALWAYS_INLINE void
vectorized_load_and_transpose(const unsigned int n_entries,
const std::array<float *, 16> &in,
- VectorizedArray<float, 16> * out)
+ VectorizedArray<float, 16> *out)
{
// see the comments in the vectorized_load_and_transpose above
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<float, 16> *in,
- const unsigned int * offsets,
- float * out)
+ const unsigned int *offsets,
+ float *out)
{
const unsigned int n_chunks = n_entries / 4;
for (unsigned int i = 0; i < n_chunks; ++i)
vectorized_transpose_and_store(const bool add_into,
const unsigned int n_entries,
const VectorizedArray<float, 16> *in,
- std::array<float *, 16> & out)
+ std::array<float *, 16> &out)
{
// see the comments in the vectorized_transpose_and_store above
* hold items, and the sample additional data object that will be
* passed to each worker and copier function invocation.
*/
- IteratorRangeToItemStream(const Iterator & begin,
- const Iterator & end,
+ IteratorRangeToItemStream(const Iterator &begin,
+ const Iterator &end,
const unsigned int buffer_size,
const unsigned int chunk_size,
const ScratchData &sample_scratch_data,
- const CopyData & sample_copy_data)
+ const CopyData &sample_copy_data)
: remaining_iterator_range(begin, end)
, item_buffer(buffer_size)
, sample_scratch_data(sample_scratch_data)
typename ScratchData,
typename CopyData>
void
- run(const Iterator & begin,
+ run(const Iterator &begin,
const std_cxx20::type_identity_t<Iterator> &end,
Worker worker,
Copier copier,
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data,
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length,
const unsigned int chunk_size)
{
typename ScratchData,
typename CopyData>
void
- run(const Iterator & begin,
+ run(const Iterator &begin,
const std_cxx20::type_identity_t<Iterator> &end,
Worker worker,
Copier copier,
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data)
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data)
{
// need to copy the sample since it is marked const
ScratchData scratch_data = sample_scratch_data;
run(const std::vector<std::vector<Iterator>> &colored_iterators,
Worker worker,
Copier copier,
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data)
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data)
{
// need to copy the sample since it is marked const
ScratchData scratch_data = sample_scratch_data;
{}
ScratchAndCopyDataObjects(std::unique_ptr<ScratchData> &&p,
- std::unique_ptr<CopyData> && q,
+ std::unique_ptr<CopyData> &&q,
const bool in_use)
: scratch_data(std::move(p))
, copy_data(std::move(q))
*/
WorkerAndCopier(
const std::function<void(const Iterator &, ScratchData &, CopyData &)>
- & worker,
+ &worker,
const std::function<void(const CopyData &)> &copier,
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data)
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data)
: worker(worker)
, copier(copier)
, sample_scratch_data(sample_scratch_data)
// now and expect it to still be valid after calling the worker,
// but we at least do not have to lock the following section.
ScratchData *scratch_data = nullptr;
- CopyData * copy_data = nullptr;
+ CopyData *copy_data = nullptr;
{
ScratchAndCopyDataList &scratch_and_copy_data_list = data.get();
* References to sample scratch and copy data for when we need them.
*/
const ScratchData &sample_scratch_data;
- const CopyData & sample_copy_data;
+ const CopyData &sample_copy_data;
};
/**
run(const std::vector<std::vector<Iterator>> &colored_iterators,
Worker worker,
Copier copier,
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data,
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data,
const unsigned int chunk_size)
{
// loop over the various colors of what we're given
run(const std::vector<std::vector<Iterator>> &colored_iterators,
Worker worker,
Copier copier,
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data,
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length = 2 * MultithreadInfo::n_threads(),
const unsigned int chunk_size = 8);
typename ScratchData,
typename CopyData>
void
- run(const Iterator & begin,
+ run(const Iterator &begin,
const std_cxx20::type_identity_t<Iterator> &end,
Worker worker,
Copier copier,
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data,
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length = 2 * MultithreadInfo::n_threads(),
const unsigned int chunk_size = 8)
{
Worker worker,
Copier copier,
const ScratchData &sample_scratch_data,
- const CopyData & sample_copy_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length = 2 * MultithreadInfo::n_threads(),
const unsigned int chunk_size = 8)
{
run(const IteratorRange<Iterator> &iterator_range,
Worker worker,
Copier copier,
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data,
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length = 2 * MultithreadInfo::n_threads(),
const unsigned int chunk_size = 8)
{
run(const std::vector<std::vector<Iterator>> &colored_iterators,
Worker worker,
Copier copier,
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data,
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length,
const unsigned int chunk_size)
{
typename ScratchData,
typename CopyData>
void
- run(const Iterator & begin,
+ run(const Iterator &begin,
const std_cxx20::type_identity_t<Iterator> &end,
- MainClass & main_object,
+ MainClass &main_object,
void (MainClass::*worker)(const Iterator &, ScratchData &, CopyData &),
void (MainClass::*copier)(const CopyData &),
const ScratchData &sample_scratch_data,
- const CopyData & sample_copy_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length = 2 * MultithreadInfo::n_threads(),
const unsigned int chunk_size = 8)
{
begin,
end,
[&main_object, worker](const Iterator &iterator,
- ScratchData & scratch_data,
- CopyData & copy_data) {
+ ScratchData &scratch_data,
+ CopyData ©_data) {
(main_object.*worker)(iterator, scratch_data, copy_data);
},
[&main_object, copier](const CopyData ©_data) {
typename ScratchData,
typename CopyData>
void
- run(const IteratorOverIterators<Iterator> & begin,
+ run(const IteratorOverIterators<Iterator> &begin,
const IteratorOverIterators<std_cxx20::type_identity_t<Iterator>> &end,
MainClass &main_object,
void (MainClass::*worker)(const Iterator &, ScratchData &, CopyData &),
void (MainClass::*copier)(const CopyData &),
const ScratchData &sample_scratch_data,
- const CopyData & sample_copy_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length = 2 * MultithreadInfo::n_threads(),
const unsigned int chunk_size = 8)
{
begin,
end,
[&main_object, worker](const Iterator &iterator,
- ScratchData & scratch_data,
- CopyData & copy_data) {
+ ScratchData &scratch_data,
+ CopyData ©_data) {
(main_object.*worker)(iterator, scratch_data, copy_data);
},
[&main_object, copier](const CopyData ©_data) {
void
run(
IteratorRangeType iterator_range,
- MainClass & main_object,
+ MainClass &main_object,
void (MainClass::*worker)(
const typename std_cxx20::type_identity_t<IteratorRangeType>::iterator &,
ScratchData &,
CopyData &),
void (MainClass::*copier)(const CopyData &),
const ScratchData &sample_scratch_data,
- const CopyData & sample_copy_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length = 2 * MultithreadInfo::n_threads(),
const unsigned int chunk_size = 8)
{
typename CopyData>
void
run(IteratorRange<Iterator> iterator_range,
- MainClass & main_object,
+ MainClass &main_object,
void (MainClass::*worker)(const Iterator &, ScratchData &, CopyData &),
void (MainClass::*copier)(const CopyData &),
const ScratchData &sample_scratch_data,
- const CopyData & sample_copy_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length = 2 * MultithreadInfo::n_threads(),
const unsigned int chunk_size = 8)
{
compute_intersection_of_cells(
const typename Triangulation<dim0, spacedim>::cell_iterator &cell0,
const typename Triangulation<dim1, spacedim>::cell_iterator &cell1,
- const Mapping<dim0, spacedim> & mapping0,
- const Mapping<dim1, spacedim> & mapping1,
+ const Mapping<dim0, spacedim> &mapping0,
+ const Mapping<dim1, spacedim> &mapping1,
const double tol = 1e-9);
void
dealii_cell_to_cgal_surface_mesh(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator &cell,
- const dealii::Mapping<dim, spacedim> & mapping,
- CGAL::Surface_mesh<CGALPointType> & mesh);
+ const dealii::Mapping<dim, spacedim> &mapping,
+ CGAL::Surface_mesh<CGALPointType> &mesh);
/**
* Convert a deal.II triangulation to a CGAL::Surface_mesh. The output depends
void
dealii_tria_to_cgal_surface_mesh(
const dealii::Triangulation<dim, spacedim> &triangulation,
- CGAL::Surface_mesh<CGALPointType> & mesh);
+ CGAL::Surface_mesh<CGALPointType> &mesh);
} // namespace CGALWrappers
template <typename CGALTriangulation, int dim, int spacedim>
void
cgal_triangulation_to_dealii_triangulation(
- const CGALTriangulation & cgal_triangulation,
+ const CGALTriangulation &cgal_triangulation,
Triangulation<dim, spacedim> &dealii_triangulation);
/**
const CGAL::Mesh_complex_3_in_triangulation_3<CGALTriangulationType,
CornerIndexType,
CurveIndexType>
- & cgal_triangulation,
+ &cgal_triangulation,
Triangulation<3> &dealii_triangulation);
/**
const CGAL::Mesh_complex_3_in_triangulation_3<CGALTriangulationType,
CornerIndexType,
CurveIndexType>
- & cgal_triangulation,
+ &cgal_triangulation,
Triangulation<3> &dealii_triangulation)
{
using C3T3 = CGAL::Mesh_complex_3_in_triangulation_3<CGALTriangulationType,
template <typename CGALTriangulation, int dim, int spacedim>
void
cgal_triangulation_to_dealii_triangulation(
- const CGALTriangulation & cgal_triangulation,
+ const CGALTriangulation &cgal_triangulation,
Triangulation<dim, spacedim> &dealii_triangulation)
{
AssertThrow(cgal_triangulation.dimension() == dim,
{
// An edge is identified by a face and a vertex index in the
// face
- const auto & f = e.first;
- const auto & i = e.second;
+ const auto &f = e.first;
+ const auto &i = e.second;
CellData<dim> cell(ReferenceCells::Line.n_vertices());
unsigned int id = 0;
// Since an edge is identified by a face (a triangle) and the
{
// A facet is identified by a cell and the opposite vertex index
// in the face
- const auto & c = facet.first;
- const auto & i = facet.second;
+ const auto &c = facet.first;
+ const auto &i = facet.second;
CellData<dim> cell(ReferenceCells::Triangle.n_vertices());
unsigned int id = 0;
// Since a face is identified by a cell (a tetrahedron) and the
void
cgal_surface_mesh_to_cgal_triangulation(
CGAL::Surface_mesh<typename C3t3::Point::Point> &surface_mesh,
- C3t3 & triangulation,
+ C3t3 &triangulation,
const AdditionalData<3> &data = AdditionalData<3>{});
/**
compute_boolean_operation(
const CGAL::Surface_mesh<CGALPointType> &surface_mesh_1,
const CGAL::Surface_mesh<CGALPointType> &surface_mesh_2,
- const BooleanOperation & boolean_operation,
- CGAL::Surface_mesh<CGALPointType> & output_surface_mesh);
+ const BooleanOperation &boolean_operation,
+ CGAL::Surface_mesh<CGALPointType> &output_surface_mesh);
/**
* Given a CGAL Triangulation describing a polyhedral region, create
const typename dealii::Triangulation<dim0, spacedim>::cell_iterator &cell0,
const typename dealii::Triangulation<dim1, spacedim>::cell_iterator &cell1,
const unsigned int degree,
- const BooleanOperation & bool_op,
+ const BooleanOperation &bool_op,
const Mapping<dim0, spacedim> &mapping0 =
(ReferenceCells::get_hypercube<dim0>()
.template get_default_linear_mapping<dim0, spacedim>()),
template <typename CGALPointType>
void
remesh_surface(CGAL::Surface_mesh<CGALPointType> &surface_mesh,
- const AdditionalData<3> & data = AdditionalData<3>{});
+ const AdditionalData<3> &data = AdditionalData<3>{});
} // namespace CGALWrappers
# ifndef DOXYGEN
void
cgal_surface_mesh_to_cgal_triangulation(
CGAL::Surface_mesh<typename C3t3::Point::Point> &surface_mesh,
- C3t3 & triangulation,
- const AdditionalData<3> & data)
+ C3t3 &triangulation,
+ const AdditionalData<3> &data)
{
using CGALPointType = typename C3t3::Point::Point;
Assert(CGAL::is_closed(surface_mesh),
compute_boolean_operation(
const CGAL::Surface_mesh<CGALPointType> &surface_mesh_1,
const CGAL::Surface_mesh<CGALPointType> &surface_mesh_2,
- const BooleanOperation & boolean_operation,
- CGAL::Surface_mesh<CGALPointType> & output_surface_mesh)
+ const BooleanOperation &boolean_operation,
+ CGAL::Surface_mesh<CGALPointType> &output_surface_mesh)
{
Assert(output_surface_mesh.is_empty(),
ExcMessage(
const typename dealii::Triangulation<dim0, spacedim>::cell_iterator &cell0,
const typename dealii::Triangulation<dim1, spacedim>::cell_iterator &cell1,
const unsigned int degree,
- const BooleanOperation & bool_op,
+ const BooleanOperation &bool_op,
const Mapping<dim0, spacedim> &mapping0,
const Mapping<dim1, spacedim> &mapping1)
{
template <typename CGALPointType>
void
remesh_surface(CGAL::Surface_mesh<CGALPointType> &cgal_mesh,
- const AdditionalData<3> & data)
+ const AdditionalData<3> &data)
{
using K = CGAL::Exact_predicates_inexact_constructions_kernel;
using Mesh_domain = CGAL::Polyhedral_mesh_domain_with_features_3<K>;
std::vector<Point<spacedim>>
get_vertices_in_cgal_order(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator &cell,
- const Mapping<dim, spacedim> & mapping)
+ const Mapping<dim, spacedim> &mapping)
{
// Elements have to be rectangular or simplices
const unsigned int n_vertices = cell->n_vertices();
get_vertices_in_cgal_order(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const Mapping<dim, spacedim> & mapping)
+ const Mapping<dim, spacedim> &mapping)
{
// Elements have to be rectangular or simplices
const unsigned int n_vertices = cell->face(face_no)->n_vertices();
void
print_tape_stats(
const typename Types<ADNumberType>::tape_index tape_index,
- std::ostream & stream) const;
+ std::ostream &stream) const;
/** @} */
void
gradient(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<ScalarType> &independent_variables,
- Vector<ScalarType> & gradient) const;
+ Vector<ScalarType> &gradient) const;
/**
* Compute the Hessian of the scalar field with respect to all
void
hessian(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<ScalarType> &independent_variables,
- FullMatrix<ScalarType> & hessian) const;
+ FullMatrix<ScalarType> &hessian) const;
/** @} */
values(const typename Types<ADNumberType>::tape_index active_tape_index,
const unsigned int n_dependent_variables,
const std::vector<ScalarType> &independent_variables,
- Vector<ScalarType> & values) const;
+ Vector<ScalarType> &values) const;
/**
* Compute the Jacobian of the vector field.
jacobian(const typename Types<ADNumberType>::tape_index active_tape_index,
const unsigned int n_dependent_variables,
const std::vector<ScalarType> &independent_variables,
- FullMatrix<ScalarType> & jacobian) const;
+ FullMatrix<ScalarType> &jacobian) const;
/** @} */
};
void
gradient(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- Vector<ScalarType> & gradient) const;
+ Vector<ScalarType> &gradient) const;
/**
* Compute the Hessian of the scalar field with respect to all
void
hessian(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- FullMatrix<ScalarType> & hessian) const;
+ FullMatrix<ScalarType> &hessian) const;
/** @} */
*/
void
values(const std::vector<ADNumberType> &dependent_variables,
- Vector<ScalarType> & values) const;
+ Vector<ScalarType> &values) const;
/**
* Compute the Jacobian of the vector field.
void
jacobian(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- FullMatrix<ScalarType> & jacobian) const;
+ FullMatrix<ScalarType> &jacobian) const;
/** @} */
};
void
print_tape_stats(
const typename Types<ADNumberType>::tape_index tape_index,
- std::ostream & stream) const;
+ std::ostream &stream) const;
/** @} */
void
gradient(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
- Vector<scalar_type> & gradient) const;
+ Vector<scalar_type> &gradient) const;
void
hessian(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
- FullMatrix<scalar_type> & hessian) const;
+ FullMatrix<scalar_type> &hessian) const;
/** @} */
values(const typename Types<ADNumberType>::tape_index active_tape_index,
const unsigned int n_dependent_variables,
const std::vector<scalar_type> &independent_variables,
- Vector<scalar_type> & values) const;
+ Vector<scalar_type> &values) const;
void
jacobian(const typename Types<ADNumberType>::tape_index active_tape_index,
const unsigned int n_dependent_variables,
const std::vector<scalar_type> &independent_variables,
- FullMatrix<scalar_type> & jacobian) const;
+ FullMatrix<scalar_type> &jacobian) const;
/** @} */
void
print_tape_stats(
const typename Types<ADNumberType>::tape_index tape_index,
- std::ostream & stream) const;
+ std::ostream &stream) const;
/** @} */
void
gradient(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
- Vector<scalar_type> & gradient) const;
+ Vector<scalar_type> &gradient) const;
void
hessian(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
- FullMatrix<scalar_type> & hessian) const;
+ FullMatrix<scalar_type> &hessian) const;
/** @} */
values(const typename Types<ADNumberType>::tape_index active_tape_index,
const unsigned int n_dependent_variables,
const std::vector<scalar_type> &independent_variables,
- Vector<scalar_type> & values) const;
+ Vector<scalar_type> &values) const;
void
jacobian(const typename Types<ADNumberType>::tape_index active_tape_index,
const unsigned int n_dependent_variables,
const std::vector<scalar_type> &independent_variables,
- FullMatrix<scalar_type> & jacobian) const;
+ FullMatrix<scalar_type> &jacobian) const;
/** @} */
void
gradient(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- Vector<ScalarType> & gradient) const;
+ Vector<ScalarType> &gradient) const;
void
hessian(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- FullMatrix<ScalarType> & hessian) const;
+ FullMatrix<ScalarType> &hessian) const;
/** @} */
void
values(const std::vector<ADNumberType> &dependent_variables,
- Vector<ScalarType> & values) const;
+ Vector<ScalarType> &values) const;
void
jacobian(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- FullMatrix<ScalarType> & jacobian) const;
+ FullMatrix<ScalarType> &jacobian) const;
/** @} */
void
gradient(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- Vector<ScalarType> & gradient) const;
+ Vector<ScalarType> &gradient) const;
void
hessian(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- FullMatrix<ScalarType> & hessian) const;
+ FullMatrix<ScalarType> &hessian) const;
/** @} */
void
values(const std::vector<ADNumberType> &dependent_variables,
- Vector<ScalarType> & values) const;
+ Vector<ScalarType> &values) const;
void
jacobian(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- FullMatrix<ScalarType> & jacobian) const;
+ FullMatrix<ScalarType> &jacobian) const;
/** @} */
*/
void
print_tape_stats(const typename Types<ad_type>::tape_index tape_index,
- std::ostream & stream) const;
+ std::ostream &stream) const;
/** @} */
*/
void
register_dependent_variable(const unsigned int index,
- const ad_type & func);
+ const ad_type &func);
/** @} */
template <typename VectorType>
void
register_dof_values(
- const VectorType & values,
+ const VectorType &values,
const std::vector<dealii::types::global_dof_index> &local_dof_indices);
/**
template <typename VectorType>
void
set_dof_values(
- const VectorType & values,
+ const VectorType &values,
const std::vector<dealii::types::global_dof_index> &local_dof_indices);
/** @} */
*/
template <typename TensorType, typename NumberType>
inline void
- set_tensor_entry(TensorType & t,
+ set_tensor_entry(TensorType &t,
const unsigned int unrolled_index,
- const NumberType & value)
+ const NumberType &value)
{
// Where possible, set values using TableIndices
AssertIndexRange(unrolled_index, t.n_independent_components);
inline void
set_tensor_entry(Tensor<0, dim, NumberType> &t,
const unsigned int unrolled_index,
- const NumberType & value)
+ const NumberType &value)
{
AssertIndexRange(unrolled_index, 1);
(void)unrolled_index;
*/
template <typename NumberType>
inline void
- set_tensor_entry(NumberType & t,
+ set_tensor_entry(NumberType &t,
const unsigned int unrolled_index,
- const NumberType & value)
+ const NumberType &value)
{
AssertIndexRange(unrolled_index, 1);
(void)unrolled_index;
set_tensor_entry(SymmetricTensor<4, dim, NumberType> &t,
const unsigned int unrolled_index_row,
const unsigned int unrolled_index_col,
- const NumberType & value)
+ const NumberType &value)
{
// Fourth order symmetric tensors require a specialized interface
// to extract values.
*/
template <typename ValueType, typename ExtractorType>
void
- register_independent_variable(const ValueType & value,
+ register_independent_variable(const ValueType &value,
const ExtractorType &extractor);
/**
*/
template <typename ValueType, typename ExtractorType>
void
- set_independent_variable(const ValueType & value,
+ set_independent_variable(const ValueType &value,
const ExtractorType &extractor);
/** @} */
static typename internal::
ScalarFieldGradient<dim, scalar_type, ExtractorType_Row>::type
extract_gradient_component(const Vector<scalar_type> &gradient,
- const ExtractorType_Row & extractor_row);
+ const ExtractorType_Row &extractor_row);
/**
* Extract the function Hessian for a subset of independent variables
ExtractorType_Row,
ExtractorType_Col>::type
extract_hessian_component(const FullMatrix<scalar_type> &hessian,
- const ExtractorType_Row & extractor_row,
- const ExtractorType_Col & extractor_col);
+ const ExtractorType_Row &extractor_row,
+ const ExtractorType_Col &extractor_col);
/**
* Extract the function Hessian for a subset of independent variables
*/
static Tensor<0, dim, scalar_type>
extract_hessian_component(
- const FullMatrix<scalar_type> & hessian,
+ const FullMatrix<scalar_type> &hessian,
const FEValuesExtractors::Scalar &extractor_row,
const FEValuesExtractors::Scalar &extractor_col);
*/
static SymmetricTensor<4, dim, scalar_type>
extract_hessian_component(
- const FullMatrix<scalar_type> & hessian,
+ const FullMatrix<scalar_type> &hessian,
const FEValuesExtractors::SymmetricTensor<2> &extractor_row,
const FEValuesExtractors::SymmetricTensor<2> &extractor_col);
*/
template <typename ValueType, typename ExtractorType>
void
- register_dependent_variable(const ValueType & funcs,
+ register_dependent_variable(const ValueType &funcs,
const ExtractorType &extractor);
/**
static typename internal::
VectorFieldValue<dim, scalar_type, ExtractorType_Row>::type
extract_value_component(const Vector<scalar_type> &values,
- const ExtractorType_Row & extractor_row);
+ const ExtractorType_Row &extractor_row);
/**
* Extract the Jacobian of the subset of dependent functions
ExtractorType_Row,
ExtractorType_Col>::type
extract_jacobian_component(const FullMatrix<scalar_type> &jacobian,
- const ExtractorType_Row & extractor_row,
- const ExtractorType_Col & extractor_col);
+ const ExtractorType_Row &extractor_row,
+ const ExtractorType_Col &extractor_col);
/**
* Extract the Jacobian of the subset of dependent functions
*/
static Tensor<0, dim, scalar_type>
extract_jacobian_component(
- const FullMatrix<scalar_type> & jacobian,
+ const FullMatrix<scalar_type> &jacobian,
const FEValuesExtractors::Scalar &extractor_row,
const FEValuesExtractors::Scalar &extractor_col);
*/
static SymmetricTensor<4, dim, scalar_type>
extract_jacobian_component(
- const FullMatrix<scalar_type> & jacobian,
+ const FullMatrix<scalar_type> &jacobian,
const FEValuesExtractors::SymmetricTensor<2> &extractor_row,
const FEValuesExtractors::SymmetricTensor<2> &extractor_col);
template <typename VectorType>
void
CellLevelBase<ADNumberTypeCode, ScalarType>::register_dof_values(
- const VectorType & values,
+ const VectorType &values,
const std::vector<dealii::types::global_dof_index> &local_dof_indices)
{
// This is actually the same thing the set_dof_values() function,
template <typename VectorType>
void
CellLevelBase<ADNumberTypeCode, ScalarType>::set_dof_values(
- const VectorType & values,
+ const VectorType &values,
const std::vector<dealii::types::global_dof_index> &local_dof_indices)
{
Assert(local_dof_indices.size() == this->n_independent_variables(),
template <typename ValueType, typename ExtractorType>
void
PointLevelFunctionsBase<dim, ADNumberTypeCode, ScalarType>::
- register_independent_variable(const ValueType & value,
+ register_independent_variable(const ValueType &value,
const ExtractorType &extractor)
{
// This is actually the same thing as the set_independent_variable
template <typename ValueType, typename ExtractorType>
void
PointLevelFunctionsBase<dim, ADNumberTypeCode, ScalarType>::
- set_independent_variable(const ValueType & value,
+ set_independent_variable(const ValueType &value,
const ExtractorType &extractor)
{
const std::vector<unsigned int> index_set(
ExtractorType_Row>::type
ScalarFunction<dim, ADNumberTypeCode, ScalarType>::
extract_gradient_component(const Vector<scalar_type> &gradient,
- const ExtractorType_Row & extractor_row)
+ const ExtractorType_Row &extractor_row)
{
// NOTE: The order of components must be consistently defined throughout
// this class.
ExtractorType_Col>::type
ScalarFunction<dim, ADNumberTypeCode, ScalarType>::
extract_hessian_component(const FullMatrix<scalar_type> &hessian,
- const ExtractorType_Row & extractor_row,
- const ExtractorType_Col & extractor_col)
+ const ExtractorType_Row &extractor_row,
+ const ExtractorType_Col &extractor_col)
{
using InternalHessian = internal::ScalarFieldHessian<dim,
scalar_type,
template <typename ValueType, typename ExtractorType>
void
VectorFunction<dim, ADNumberTypeCode, ScalarType>::
- register_dependent_variable(const ValueType & funcs,
+ register_dependent_variable(const ValueType &funcs,
const ExtractorType &extractor)
{
const std::vector<unsigned int> index_set(
ExtractorType_Row>::type
VectorFunction<dim, ADNumberTypeCode, ScalarType>::extract_value_component(
const Vector<scalar_type> &values,
- const ExtractorType_Row & extractor_row)
+ const ExtractorType_Row &extractor_row)
{
// NOTE: The order of components must be consistently defined throughout
// this class.
ExtractorType_Col>::type
VectorFunction<dim, ADNumberTypeCode, ScalarType>::
extract_jacobian_component(const FullMatrix<scalar_type> &jacobian,
- const ExtractorType_Row & extractor_row,
- const ExtractorType_Col & extractor_col)
+ const ExtractorType_Row &extractor_row,
+ const ExtractorType_Col &extractor_col)
{
using InternalJacobian = internal::VectorFieldJacobian<dim,
scalar_type,
independent_variable(const scalar_type &in,
const unsigned int index,
const unsigned int n_independent_variables,
- ad_type & out)
+ ad_type &out)
{
// It is required that we first initialize the outer number before
// any of the nested ones.
independent_variable(const scalar_type &in,
const unsigned int index,
const unsigned int n_independent_variables,
- ad_type & out)
+ ad_type &out)
{
// For Sacado::Rad::ADvar numbers, we have to initialize the
// ADNumber with an already fully-configured value. This means
* argument.
*/
Expression(const std::vector<std::pair<Expression, Expression>>
- & condition_expression,
+ &condition_expression,
const Expression &expression_otherwise);
/**
* This constructor initializes a function symbol with a string
* representing its symbolic name.
*/
- Expression(const std::string & symbol_func,
+ Expression(const std::string &symbol_func,
const types::symbol_vector &arguments);
/**
std::stringstream sstream;
sstream << *this;
const std::string expr = sstream.str();
- ar & expr;
+ ar &expr;
}
Expression::load(Archive &ar, const unsigned int /*version*/)
{
std::string expr;
- ar & expr;
+ ar &expr;
parse(expr);
}
* their numerical value be correctly set up and maintained.
*/
void
- call(ReturnType * output_values,
+ call(ReturnType *output_values,
const types::symbol_vector &independent_symbols,
- const ReturnType * substitution_values);
+ const ReturnType *substitution_values);
/**
* Write the data of this object to a stream for the purpose
* function apply here as well.
*/
void
- call(ReturnType * output_values,
+ call(ReturnType *output_values,
const SymEngine::vec_basic &independent_symbols,
- const ReturnType * substitution_values);
+ const ReturnType *substitution_values);
private:
// Note: It would be more efficient to store this data in native
*/
void
init(const types::symbol_vector &independent_symbols,
- const Expression & dependent_function,
+ const Expression &dependent_function,
const bool use_cse = false);
/**
// The following definition is required due to base class CRTP.
void
init(const SymEngine::vec_basic &independent_symbols,
- const SymEngine::Basic & dependent_function,
+ const SymEngine::Basic &dependent_function,
const bool use_cse = false);
/**
template <typename ReturnType, typename ExpressionType>
void
CSEDictionaryVisitor<ReturnType, ExpressionType>::call(
- ReturnType * output_values,
+ ReturnType *output_values,
const SD::types::symbol_vector &independent_symbols,
- const ReturnType * substitution_values)
+ const ReturnType *substitution_values)
{
call(output_values,
Utilities::convert_expression_vector_to_basic_vector(
template <typename ReturnType, typename ExpressionType>
void
CSEDictionaryVisitor<ReturnType, ExpressionType>::call(
- ReturnType * output_values,
+ ReturnType *output_values,
const SymEngine::vec_basic &independent_symbols,
- const ReturnType * substitution_values)
+ const ReturnType *substitution_values)
{
Assert(n_reduced_expressions() > 0, ExcInternalError());
void
DictionarySubstitutionVisitor<ReturnType, ExpressionType>::init(
const types::symbol_vector &inputs,
- const SD::Expression & output,
+ const SD::Expression &output,
const bool use_cse)
{
init(inputs, types::symbol_vector{output}, use_cse);
void
DictionarySubstitutionVisitor<ReturnType, ExpressionType>::init(
const SymEngine::vec_basic &inputs,
- const SymEngine::Basic & output,
+ const SymEngine::Basic &output,
const bool use_cse)
{
init(Utilities::convert_basic_vector_to_expression_vector(inputs),
template <typename ReturnType, typename ExpressionType>
void
DictionarySubstitutionVisitor<ReturnType, ExpressionType>::call(
- ReturnType * output_values,
+ ReturnType *output_values,
const ReturnType *substitution_values)
{
// Check to see if CSE has been performed
template <class Archive>
void
DictionarySubstitutionVisitor<ReturnType, ExpressionType>::save(
- Archive & ar,
+ Archive &ar,
const unsigned int version) const
{
// Add some dynamic information to determine if CSE has been used,
template <class Archive>
void
DictionarySubstitutionVisitor<ReturnType, ExpressionType>::load(
- Archive & ar,
+ Archive &ar,
const unsigned int version)
{
Assert(cse.executed() == false, ExcInternalError());
* @param optimization_flags A set of flags that indicate the types of optimization to be performed.
*/
static void
- initialize(OptimizerType & optimizer,
- const SymEngine::vec_basic & independent_symbols,
- const SymEngine::vec_basic & dependent_functions,
+ initialize(OptimizerType &optimizer,
+ const SymEngine::vec_basic &independent_symbols,
+ const SymEngine::vec_basic &dependent_functions,
const enum OptimizationFlags &optimization_flags)
{
const bool use_symbolic_cse = use_symbolic_CSE(optimization_flags);
*/
template <class Archive>
static void
- save(Archive & archive,
+ save(Archive &archive,
const unsigned int version,
- OptimizerType & optimizer)
+ OptimizerType &optimizer)
{
optimizer.save(archive, version);
}
*/
template <class Archive>
static void
- load(Archive & archive,
+ load(Archive &archive,
const unsigned int version,
- OptimizerType & optimizer,
+ OptimizerType &optimizer,
const SymEngine::vec_basic & /*independent_symbols*/,
const SymEngine::vec_basic & /*dependent_functions*/,
const enum OptimizationFlags & /*optimization_flags*/)
*/
template <typename Stream>
static void
- print(Stream & stream,
+ print(Stream &stream,
const OptimizerType &optimizer,
const bool print_independent_symbols = false,
const bool print_dependent_functions = false,
* @param optimization_flags A set of flags that indicate the types of optimization to be performed.
*/
static void
- initialize(OptimizerType & optimizer,
- const SymEngine::vec_basic & independent_symbols,
- const SymEngine::vec_basic & dependent_functions,
+ initialize(OptimizerType &optimizer,
+ const SymEngine::vec_basic &independent_symbols,
+ const SymEngine::vec_basic &dependent_functions,
const enum OptimizationFlags &optimization_flags)
{
const bool use_symbolic_cse = use_symbolic_CSE(optimization_flags);
static void
load(Archive & /*archive*/,
const unsigned int /*version*/,
- OptimizerType & optimizer,
- const SymEngine::vec_basic & independent_symbols,
- const SymEngine::vec_basic & dependent_functions,
+ OptimizerType &optimizer,
+ const SymEngine::vec_basic &independent_symbols,
+ const SymEngine::vec_basic &dependent_functions,
const enum OptimizationFlags &optimization_flags)
{
initialize(optimizer,
* @param optimization_flags A set of flags that indicate the types of optimization to be performed.
*/
static void
- initialize(OptimizerType & optimizer,
- const SymEngine::vec_basic & independent_symbols,
- const SymEngine::vec_basic & dependent_functions,
+ initialize(OptimizerType &optimizer,
+ const SymEngine::vec_basic &independent_symbols,
+ const SymEngine::vec_basic &dependent_functions,
const enum OptimizationFlags &optimization_flags)
{
const int opt_level = get_LLVM_optimization_level(optimization_flags);
OptimizerType &optimizer)
{
const std::string llvm_compiled_function = optimizer.dumps();
- archive & llvm_compiled_function;
+ archive &llvm_compiled_function;
}
const enum OptimizationFlags & /*optimization_flags*/)
{
std::string llvm_compiled_function;
- archive & llvm_compiled_function;
+ archive &llvm_compiled_function;
optimizer.loads(llvm_compiled_function);
}
*/
static void
initialize(typename Optimizer::OptimizerType *optimizer,
- const SymEngine::vec_basic & independent_symbols,
- const SymEngine::vec_basic & dependent_functions,
- const enum OptimizationFlags & optimization_flags)
+ const SymEngine::vec_basic &independent_symbols,
+ const SymEngine::vec_basic &dependent_functions,
+ const enum OptimizationFlags &optimization_flags)
{
Assert(optimizer, ExcNotInitialized());
*/
static void
substitute(typename Optimizer::OptimizerType *optimizer,
- std::vector<ReturnType> & output_values,
- const std::vector<ReturnType> & substitution_values)
+ std::vector<ReturnType> &output_values,
+ const std::vector<ReturnType> &substitution_values)
{
Assert(optimizer, ExcNotInitialized());
optimizer->call(output_values.data(), substitution_values.data());
*/
template <class Archive>
static void
- save(Archive & archive,
+ save(Archive &archive,
const unsigned int version,
typename Optimizer::OptimizerType *optimizer)
{
*/
template <class Archive>
static void
- load(Archive & archive,
+ load(Archive &archive,
const unsigned int version,
typename Optimizer::OptimizerType *optimizer,
- const SymEngine::vec_basic & independent_symbols,
- const SymEngine::vec_basic & dependent_functions,
- const enum OptimizationFlags & optimization_flags)
+ const SymEngine::vec_basic &independent_symbols,
+ const SymEngine::vec_basic &dependent_functions,
+ const enum OptimizationFlags &optimization_flags)
{
Assert(optimizer, ExcNotInitialized());
*/
template <typename Stream>
static void
- print(Stream & stream,
+ print(Stream &stream,
typename Optimizer::OptimizerType *optimizer,
const bool print_independent_symbols = false,
const bool print_dependent_functions = false,
*/
static void
initialize(typename Optimizer::OptimizerType *optimizer,
- const SymEngine::vec_basic & independent_symbols,
- const SymEngine::vec_basic & dependent_functions,
- const enum OptimizationFlags & optimization_flags)
+ const SymEngine::vec_basic &independent_symbols,
+ const SymEngine::vec_basic &dependent_functions,
+ const enum OptimizationFlags &optimization_flags)
{
Assert(optimizer, ExcNotInitialized());
*/
static void
substitute(typename Optimizer::OptimizerType *optimizer,
- std::vector<ReturnType> & output_values,
- const std::vector<ReturnType> & substitution_values)
+ std::vector<ReturnType> &output_values,
+ const std::vector<ReturnType> &substitution_values)
{
Assert(optimizer, ExcNotInitialized());
*/
template <class Archive>
static void
- save(Archive & archive,
+ save(Archive &archive,
const unsigned int version,
typename Optimizer::OptimizerType *optimizer)
{
*/
template <class Archive>
static void
- load(Archive & archive,
+ load(Archive &archive,
const unsigned int version,
typename Optimizer::OptimizerType *optimizer,
- const SymEngine::vec_basic & independent_symbols,
- const SymEngine::vec_basic & dependent_functions,
- const enum OptimizationFlags & optimization_flags)
+ const SymEngine::vec_basic &independent_symbols,
+ const SymEngine::vec_basic &dependent_functions,
+ const enum OptimizationFlags &optimization_flags)
{
Assert(optimizer, ExcNotInitialized());
*/
template <typename Stream>
static void
- print(Stream & stream,
+ print(Stream &stream,
typename Optimizer::OptimizerType *optimizer,
const bool print_cse_reductions = true,
const bool print_independent_symbols = false,
TensorType<rank, dim, NumberType>
tensor_evaluate_optimized(
const TensorType<rank, dim, Expression> &symbol_tensor,
- const std::vector<NumberType> & cached_evaluation,
- const BatchOptimizer<NumberType> & optimizer)
+ const std::vector<NumberType> &cached_evaluation,
+ const BatchOptimizer<NumberType> &optimizer)
{
TensorType<rank, dim, NumberType> out;
for (unsigned int i = 0; i < out.n_independent_components; ++i)
SymmetricTensor<4, dim, NumberType>
tensor_evaluate_optimized(
const SymmetricTensor<4, dim, Expression> &symbol_tensor,
- const std::vector<NumberType> & cached_evaluation,
- const BatchOptimizer<NumberType> & optimizer)
+ const std::vector<NumberType> &cached_evaluation,
+ const BatchOptimizer<NumberType> &optimizer)
{
SymmetricTensor<4, dim, NumberType> out;
for (unsigned int i = 0;
template <typename NumberType, typename T>
void
register_functions(BatchOptimizer<NumberType> &optimizer,
- const T & function)
+ const T &function)
{
optimizer.register_function(function);
}
template <typename NumberType, typename T>
void
register_functions(BatchOptimizer<NumberType> &optimizer,
- const std::vector<T> & functions)
+ const std::vector<T> &functions)
{
for (const auto &function : functions)
register_functions(optimizer, function);
template <typename NumberType, typename T, typename... Args>
void
register_functions(BatchOptimizer<NumberType> &optimizer,
- const T & function,
+ const T &function,
const Args &...other_functions)
{
register_functions(optimizer, function);
* then an error will be thrown. Currently the LLVM optimization method
* is not compatible with complex numbers.
*/
- BatchOptimizer(const enum OptimizerType & optimization_method,
+ BatchOptimizer(const enum OptimizerType &optimization_method,
const enum OptimizationFlags &optimization_flags =
OptimizationFlags::optimize_all);
* then a safe default will be selected.
*/
void
- set_optimization_method(const enum OptimizerType & optimization_method,
+ set_optimization_method(const enum OptimizerType &optimization_method,
const enum OptimizationFlags &optimization_flags =
OptimizationFlags::optimize_all);
* @p values overwrites any previously computed results.
*/
void
- substitute(const types::symbol_vector & symbols,
+ substitute(const types::symbol_vector &symbols,
const std::vector<ReturnType> &values) const;
/**
* @p values overwrites any previously computed results.
*/
void
- substitute(const SymEngine::vec_basic & symbols,
+ substitute(const SymEngine::vec_basic &symbols,
const std::vector<ReturnType> &values) const;
/**
* takes no arguments.
*/
ReturnType
- extract(const Expression & func,
+ extract(const Expression &func,
const std::vector<ReturnType> &cached_evaluation) const;
template <int rank, int dim>
Tensor<rank, dim, ReturnType>
extract(const Tensor<rank, dim, Expression> &funcs,
- const std::vector<ReturnType> & cached_evaluation) const;
+ const std::vector<ReturnType> &cached_evaluation) const;
/**
template <typename ReturnType>
template <class Archive>
void
- BatchOptimizer<ReturnType>::save(Archive & ar,
+ BatchOptimizer<ReturnType>::save(Archive &ar,
const unsigned int version) const
{
// Serialize enum classes...
// Deserialize enum classes...
{
typename std::underlying_type<OptimizerType>::type m;
- ar & m;
+ ar &m;
method = static_cast<OptimizerType>(m);
}
{
typename std::underlying_type<OptimizationFlags>::type f;
- ar & f;
+ ar &f;
flags = static_cast<OptimizationFlags>(f);
}
Tensor<rank, dim, ReturnType>
BatchOptimizer<ReturnType>::extract(
const Tensor<rank, dim, Expression> &funcs,
- const std::vector<ReturnType> & cached_evaluation) const
+ const std::vector<ReturnType> &cached_evaluation) const
{
return internal::tensor_evaluate_optimized(funcs,
cached_evaluation,
SymmetricTensor<rank, dim, ReturnType>
BatchOptimizer<ReturnType>::extract(
const SymmetricTensor<rank, dim, Expression> &funcs,
- const std::vector<ReturnType> & cached_evaluation) const
+ const std::vector<ReturnType> &cached_evaluation) const
{
return internal::tensor_evaluate_optimized(funcs,
cached_evaluation,
* symbols used within a section of code.
*/
Expression
- make_symbolic_function(const std::string & symbol,
+ make_symbolic_function(const std::string &symbol,
const types::symbol_vector &arguments);
/**
* symbols used within a section of code.
*/
Expression
- make_symbolic_function(const std::string & symbol,
+ make_symbolic_function(const std::string &symbol,
const types::substitution_map &arguments);
/** @} */
*/
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const SymEngine::RCP<const SymEngine::Basic> &symbol,
const SymEngine::RCP<const SymEngine::Basic> &value);
} // namespace internal
template <bool ignore_invalid_symbols = false, typename ValueType = double>
void
add_to_symbol_map(types::substitution_map &symbol_map,
- const Expression & symbol);
+ const Expression &symbol);
/**
* A convenience function for adding an empty entry, with the key value
const SymEngine::RCP<const SymEngine::Basic> &>::value>>
void
add_to_symbol_map(types::substitution_map &symbol_map,
- const SymbolicType & symbol);
+ const SymbolicType &symbol);
/**
* A convenience function for adding empty entries, with the key values
typename ValueType = double,
typename SymbolicType>
void
- add_to_symbol_map(types::substitution_map & symbol_map,
+ add_to_symbol_map(types::substitution_map &symbol_map,
const std::vector<SymbolicType> &symbols);
/**
*/
template <bool ignore_invalid_symbols = false, typename ValueType = double>
void
- add_to_symbol_map(types::substitution_map & symbol_map,
+ add_to_symbol_map(types::substitution_map &symbol_map,
const types::substitution_map &other_symbols);
/**
typename... Args>
void
add_to_symbol_map(types::substitution_map &symbol_map,
- const SymbolicType & symbol,
+ const SymbolicType &symbol,
const Args &...other_symbols);
/**
*/
void
set_value_in_symbol_map(types::substitution_map &substitution_map,
- const Expression & symbol,
- const Expression & value);
+ const Expression &symbol,
+ const Expression &value);
/**
* Find the entry for @p symbol in the @p substitution_map and set its
std::is_constructible_v<SymbolicType, ValueType>>>
void
set_value_in_symbol_map(types::substitution_map &substitution_map,
- const SymbolicType & symbol,
- const ValueType & value);
+ const SymbolicType &symbol,
+ const ValueType &value);
/**
* Find the entries for @p symbols in the @p substitution_map and set their
*/
template <typename SymbolicType, typename ValueType>
void
- set_value_in_symbol_map(types::substitution_map & substitution_map,
+ set_value_in_symbol_map(types::substitution_map &substitution_map,
const std::vector<SymbolicType> &symbols,
- const std::vector<ValueType> & values);
+ const std::vector<ValueType> &values);
/**
* Find the entry for @p symbols in the @p substitution_map and set their
template <typename SymbolicType, typename ValueType>
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::pair<SymbolicType, ValueType> &symbol_value);
/**
template <typename SymbolicType, typename ValueType, typename... Args>
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::pair<SymbolicType, ValueType> &symbol_value,
const Args &...other_symbol_values);
template <typename SymbolicType, typename ValueType>
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::vector<std::pair<SymbolicType, ValueType>> &symbol_values);
/**
* to conduct symbolic substitution operations (i.e., a substitution map).
*/
void
- set_value_in_symbol_map(types::substitution_map & substitution_map,
+ set_value_in_symbol_map(types::substitution_map &substitution_map,
const types::substitution_map &symbol_values);
/** @} */
template <typename ExpressionType, typename ValueType>
types::substitution_map
make_substitution_map(const std::vector<ExpressionType> &symbols,
- const std::vector<ValueType> & values);
+ const std::vector<ValueType> &values);
/**
* Return a substitution map that has the key given by the first entry in
template <bool ignore_invalid_symbols = false>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const SymEngine::RCP<const SymEngine::Basic> &symbol,
const SymEngine::RCP<const SymEngine::Basic> &value);
} // namespace internal
template <bool ignore_invalid_symbols = false>
void
add_to_substitution_map(types::substitution_map &substitution_map,
- const Expression & symbol,
- const Expression & value);
+ const Expression &symbol,
+ const Expression &value);
/**
* A convenience function to add an entry to the @p substitution_map.
std::is_constructible_v<ExpressionType, ValueType>>>
void
add_to_substitution_map(types::substitution_map &substitution_map,
- const ExpressionType & symbol,
- const ValueType & value);
+ const ExpressionType &symbol,
+ const ValueType &value);
/**
* A convenience function for adding multiple entries to the
const SymEngine::RCP<const SymEngine::Basic> &>::value &&
std::is_constructible_v<ExpressionType, ValueType>>>
void
- add_to_substitution_map(types::substitution_map & substitution_map,
+ add_to_substitution_map(types::substitution_map &substitution_map,
const std::vector<ExpressionType> &symbols,
- const std::vector<ValueType> & values);
+ const std::vector<ValueType> &values);
/**
* A convenience function for adding multiple entries to the
*/
template <bool ignore_invalid_symbols = false>
void
- add_to_substitution_map(types::substitution_map & substitution_map,
+ add_to_substitution_map(types::substitution_map &substitution_map,
const types::substitution_map &symbol_values);
/**
typename ValueType>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::pair<ExpressionType, ValueType> &symbol_value);
/**
typename ValueType>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::vector<std::pair<ExpressionType, ValueType>> &symbol_values);
/**
typename... Args>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::pair<ExpressionType, ValueType> &symbol_value,
const Args &...other_symbol_values);
* values are equal. If this is not the case then an error will be thrown.
*/
void
- merge_substitution_maps(types::substitution_map & substitution_map_out,
+ merge_substitution_maps(types::substitution_map &substitution_map_out,
const types::substitution_map &substitution_map_in);
/**
*/
template <typename... Args>
void
- merge_substitution_maps(types::substitution_map & substitution_map_out,
+ merge_substitution_maps(types::substitution_map &substitution_map_out,
const types::substitution_map &substitution_map_in,
const Args &...other_substitution_maps_in);
* </ol>
*/
Expression
- substitute(const Expression & expression,
+ substitute(const Expression &expression,
const types::substitution_map &substitution_map);
/**
Expression
substitute(const Expression &expression,
const Expression &symbol,
- const ValueType & value);
+ const ValueType &value);
/**
* Perform a single substitution sweep of a set of symbols into the given
*/
template <typename ValueType>
ValueType
- substitute_and_evaluate(const Expression & expression,
+ substitute_and_evaluate(const Expression &expression,
const types::substitution_map &substitution_map);
/**
template <bool ignore_invalid_symbols, typename ValueType>
void
add_to_symbol_map(types::substitution_map &symbol_map,
- const Expression & symbol)
+ const Expression &symbol)
{
// Call the above function
add_to_substitution_map<ignore_invalid_symbols>(
typename>
void
add_to_symbol_map(types::substitution_map &symbol_map,
- const SymbolicType & symbol)
+ const SymbolicType &symbol)
{
// Call the above function
using SE_RCP_Basic = const SymEngine::RCP<const SymEngine::Basic> &;
typename ValueType,
typename SymbolicType>
void
- add_to_symbol_map(types::substitution_map & symbol_map,
+ add_to_symbol_map(types::substitution_map &symbol_map,
const std::vector<SymbolicType> &symbols)
{
for (const auto &symbol : symbols)
template <bool ignore_invalid_symbols, typename ValueType>
void
- add_to_symbol_map(types::substitution_map & symbol_map,
+ add_to_symbol_map(types::substitution_map &symbol_map,
const types::substitution_map &other_symbols)
{
// We should be cautious as to whether or not the user has
typename... Args>
void
add_to_symbol_map(types::substitution_map &symbol_map,
- const SymbolicType & symbol,
+ const SymbolicType &symbol,
const Args &...other_symbols)
{
add_to_symbol_map<ignore_invalid_symbols, ValueType>(symbol_map, symbol);
template <typename SymbolicType, typename ValueType, typename>
void
set_value_in_symbol_map(types::substitution_map &substitution_map,
- const SymbolicType & symbol,
- const ValueType & value)
+ const SymbolicType &symbol,
+ const ValueType &value)
{
// Call the above function
using SE_RCP_Basic = const SymEngine::RCP<const SymEngine::Basic> &;
template <typename SymbolicType, typename ValueType>
void
- set_value_in_symbol_map(types::substitution_map & substitution_map,
+ set_value_in_symbol_map(types::substitution_map &substitution_map,
const std::vector<SymbolicType> &symbols,
- const std::vector<ValueType> & values)
+ const std::vector<ValueType> &values)
{
Assert(symbols.size() == values.size(),
ExcDimensionMismatch(symbols.size(), values.size()));
template <typename SymbolicType, typename ValueType>
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::pair<SymbolicType, ValueType> &symbol_value)
{
set_value_in_symbol_map(substitution_map,
template <typename SymbolicType, typename ValueType, typename... Args>
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::pair<SymbolicType, ValueType> &symbol_value,
const Args &...other_symbol_values)
{
template <typename SymbolicType, typename ValueType>
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::vector<std::pair<SymbolicType, ValueType>> &symbol_values)
{
// Call the above function
template <typename ExpressionType, typename ValueType>
types::substitution_map
make_substitution_map(const std::vector<ExpressionType> &symbols,
- const std::vector<ValueType> & values)
+ const std::vector<ValueType> &values)
{
types::substitution_map substitution_map;
add_to_substitution_map(substitution_map, symbols, values);
template <bool ignore_invalid_symbols>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const SymEngine::RCP<const SymEngine::Basic> &symbol,
const SymEngine::RCP<const SymEngine::Basic> &value)
{
template <bool ignore_invalid_symbols>
void
add_to_substitution_map(types::substitution_map &substitution_map,
- const Expression & symbol,
- const Expression & value)
+ const Expression &symbol,
+ const Expression &value)
{
internal::add_to_substitution_map<ignore_invalid_symbols>(
substitution_map, symbol.get_RCP(), value.get_RCP());
typename>
void
add_to_substitution_map(types::substitution_map &substitution_map,
- const ExpressionType & symbol,
- const ValueType & value)
+ const ExpressionType &symbol,
+ const ValueType &value)
{
using SE_RCP_Basic = const SymEngine::RCP<const SymEngine::Basic> &;
internal::add_to_substitution_map<ignore_invalid_symbols>(
typename ValueType,
typename>
void
- add_to_substitution_map(types::substitution_map & substitution_map,
+ add_to_substitution_map(types::substitution_map &substitution_map,
const std::vector<ExpressionType> &symbols,
- const std::vector<ValueType> & values)
+ const std::vector<ValueType> &values)
{
Assert(symbols.size() == values.size(),
ExcMessage(
typename ValueType>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::pair<ExpressionType, ValueType> &symbol_value)
{
add_to_substitution_map<ignore_invalid_symbols>(substitution_map,
typename ValueType>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::vector<std::pair<ExpressionType, ValueType>> &symbol_values)
{
for (const auto &entry : symbol_values)
template <bool ignore_invalid_symbols>
void
- add_to_substitution_map(types::substitution_map & substitution_map,
+ add_to_substitution_map(types::substitution_map &substitution_map,
const types::substitution_map &symbol_values)
{
for (const auto &entry : symbol_values)
typename... Args>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const std::pair<ExpressionType, ValueType> &symbol_value,
const Args &...other_symbol_values)
{
template <typename... Args>
void
merge_substitution_maps(
- types::substitution_map & substitution_map_out,
+ types::substitution_map &substitution_map_out,
const types::substitution_map &substitution_map_in_1,
const Args &...other_substitution_maps_in)
{
Expression
substitute(const Expression &expression,
const Expression &symbol,
- const ValueType & value)
+ const ValueType &value)
{
return expression.substitute(symbol, value);
}
template <typename ValueType>
ValueType
- substitute_and_evaluate(const Expression & expression,
+ substitute_and_evaluate(const Expression &expression,
const types::substitution_map &substitution_map)
{
return expression.substitute_and_evaluate<ValueType>(substitution_map);
*/
template <int dim>
Tensor<1, dim, Expression>
- make_vector_of_symbolic_functions(const std::string & symbol,
+ make_vector_of_symbolic_functions(const std::string &symbol,
const types::substitution_map &arguments);
/**
*/
template <int rank, int dim>
Tensor<rank, dim, Expression>
- make_tensor_of_symbolic_functions(const std::string & symbol,
+ make_tensor_of_symbolic_functions(const std::string &symbol,
const types::substitution_map &arguments);
/**
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
make_symmetric_tensor_of_symbolic_functions(
- const std::string & symbol,
+ const std::string &symbol,
const types::substitution_map &arguments);
/** @} */
*/
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
- differentiate(const Expression & f,
+ differentiate(const Expression &f,
const SymmetricTensor<rank, dim, Expression> &S);
/**
*/
template <int rank, int dim>
Tensor<rank, dim, Expression>
- differentiate(const Tensor<0, dim, Expression> & f,
+ differentiate(const Tensor<0, dim, Expression> &f,
const Tensor<rank, dim, Expression> &T);
/**
*/
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
- differentiate(const Tensor<0, dim, Expression> & f,
+ differentiate(const Tensor<0, dim, Expression> &f,
const SymmetricTensor<rank, dim, Expression> &S);
/**
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
differentiate(const SymmetricTensor<rank, dim, Expression> &S,
- const Expression & x);
+ const Expression &x);
/**
* Return the symbolic result of computing the partial derivative of the
template <int rank, int dim>
Tensor<rank, dim, Expression>
differentiate(const Tensor<rank, dim, Expression> &T,
- const Tensor<0, dim, Expression> & x);
+ const Tensor<0, dim, Expression> &x);
/**
* Return the symbolic result of computing the partial derivative of the
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
differentiate(const SymmetricTensor<rank, dim, Expression> &S,
- const Tensor<0, dim, Expression> & x);
+ const Tensor<0, dim, Expression> &x);
/**
* Return the symbolic result of computing the partial derivative of the
*/
template <int rank_1, int rank_2, int dim>
Tensor<rank_1 + rank_2, dim, Expression>
- differentiate(const Tensor<rank_1, dim, Expression> & T,
+ differentiate(const Tensor<rank_1, dim, Expression> &T,
const SymmetricTensor<rank_2, dim, Expression> &S);
/**
template <int rank_1, int rank_2, int dim>
Tensor<rank_1 + rank_2, dim, Expression>
differentiate(const SymmetricTensor<rank_1, dim, Expression> &S,
- const Tensor<rank_2, dim, Expression> & T);
+ const Tensor<rank_2, dim, Expression> &T);
/** @} */
int dim,
typename SymbolicType>
void
- add_to_symbol_map(types::substitution_map & symbol_map,
+ add_to_symbol_map(types::substitution_map &symbol_map,
const Tensor<rank, dim, SymbolicType> &symbol_tensor);
/**
typename SymbolicType>
void
add_to_symbol_map(
- types::substitution_map & symbol_map,
+ types::substitution_map &symbol_map,
const SymmetricTensor<rank, dim, SymbolicType> &symbol_tensor);
/**
template <int rank, int dim, typename SymbolicType, typename ValueType>
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const Tensor<rank, dim, SymbolicType> &symbol_tensor,
- const Tensor<rank, dim, ValueType> & value_tensor);
+ const Tensor<rank, dim, ValueType> &value_tensor);
/**
* Find the input @p symbols in the @p substitution_map and set the entries
template <int rank, int dim, typename SymbolicType, typename ValueType>
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const SymmetricTensor<rank, dim, SymbolicType> &symbol_tensor,
- const SymmetricTensor<rank, dim, ValueType> & value_tensor);
+ const SymmetricTensor<rank, dim, ValueType> &value_tensor);
/** @} */
types::substitution_map
make_substitution_map(
const Tensor<rank, dim, ExpressionType> &symbol_tensor,
- const Tensor<rank, dim, ValueType> & value_tensor);
+ const Tensor<rank, dim, ValueType> &value_tensor);
/**
* Return a substitution map that has the entry keys given by the
types::substitution_map
make_substitution_map(
const SymmetricTensor<rank, dim, ExpressionType> &symbol_tensor,
- const SymmetricTensor<rank, dim, ValueType> & value_tensor);
+ const SymmetricTensor<rank, dim, ValueType> &value_tensor);
/** @} */
typename ValueType>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const Tensor<rank, dim, ExpressionType> &symbol_tensor,
- const Tensor<rank, dim, ValueType> & value_tensor);
+ const Tensor<rank, dim, ValueType> &value_tensor);
/**
* A convenience function for adding an entry to the @p substitution_map.
typename ValueType>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const SymmetricTensor<rank, dim, ExpressionType> &symbol_tensor,
- const SymmetricTensor<rank, dim, ValueType> & value_tensor);
+ const SymmetricTensor<rank, dim, ValueType> &value_tensor);
/** @} */
template <int rank, int dim>
Tensor<rank, dim, Expression>
substitute(const Tensor<rank, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map);
+ const types::substitution_map &substitution_map);
/**
* Perform a single substitution sweep of a set of symbols into the given
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
substitute(const SymmetricTensor<rank, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map);
+ const types::substitution_map &substitution_map);
/**
* Perform a single substitution sweep of a set of symbols into the given
Tensor<rank, dim, ValueType>
substitute_and_evaluate(
const Tensor<rank, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map);
+ const types::substitution_map &substitution_map);
/**
* Perform a single substitution sweep of a set of symbols into the given
SymmetricTensor<rank, dim, ValueType>
substitute_and_evaluate(
const SymmetricTensor<rank, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map);
+ const types::substitution_map &substitution_map);
/** @} */
template <int, int, typename>
class TensorType>
TensorType<0, dim, ValueType>
- scalar_diff_tensor(const ValueType & func,
+ scalar_diff_tensor(const ValueType &func,
const TensorType<0, dim, ValueType> &op)
{
return differentiate(func, op);
template <int, int, typename>
class TensorType>
TensorType<rank, dim, ValueType>
- scalar_diff_tensor(const ValueType & func,
+ scalar_diff_tensor(const ValueType &func,
const TensorType<rank, dim, ValueType> &op)
{
TensorType<rank, dim, ValueType> out;
template <int, int, typename>
class TensorType>
TensorType<rank, dim, ValueType>
- tensor_diff_tensor(const TensorType<0, dim, ValueType> & func,
+ tensor_diff_tensor(const TensorType<0, dim, ValueType> &func,
const TensorType<rank, dim, ValueType> &op)
{
TensorType<rank, dim, ValueType> out;
class TensorType>
TensorType<rank, dim, ValueType>
tensor_diff_scalar(const TensorType<rank, dim, ValueType> &funcs,
- const ValueType & op)
+ const ValueType &op)
{
TensorType<rank, dim, ValueType> out;
for (unsigned int i = 0; i < out.n_independent_components; ++i)
class TensorType>
TensorType<rank, dim, ValueType>
tensor_diff_tensor(const TensorType<rank, dim, ValueType> &funcs,
- const TensorType<0, dim, ValueType> & op)
+ const TensorType<0, dim, ValueType> &op)
{
TensorType<rank, dim, ValueType> out;
for (unsigned int i = 0; i < out.n_independent_components; ++i)
template <int rank, int dim>
Tensor<rank, dim, Expression>
- differentiate(const Expression & func,
+ differentiate(const Expression &func,
const Tensor<rank, dim, Expression> &op)
{
return internal::scalar_diff_tensor(func, op);
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
- differentiate(const Expression & func,
+ differentiate(const Expression &func,
const SymmetricTensor<rank, dim, Expression> &op)
{
return internal::scalar_diff_tensor(func, op);
template <int rank, int dim>
Tensor<rank, dim, Expression>
- differentiate(const Tensor<0, dim, Expression> & func,
+ differentiate(const Tensor<0, dim, Expression> &func,
const Tensor<rank, dim, Expression> &op)
{
return internal::scalar_diff_tensor(func, op);
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
- differentiate(const Tensor<0, dim, Expression> & func,
+ differentiate(const Tensor<0, dim, Expression> &func,
const SymmetricTensor<rank, dim, Expression> &op)
{
// Ensure that this returns a symmetric tensor by
template <int rank, int dim>
Tensor<rank, dim, Expression>
differentiate(const Tensor<rank, dim, Expression> &symbol_tensor,
- const Expression & op)
+ const Expression &op)
{
return internal::tensor_diff_scalar(symbol_tensor, op);
}
template <int rank, int dim>
Tensor<rank, dim, Expression>
differentiate(const Tensor<rank, dim, Expression> &symbol_tensor,
- const Tensor<0, dim, Expression> & op)
+ const Tensor<0, dim, Expression> &op)
{
return internal::tensor_diff_scalar(symbol_tensor, op);
}
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
differentiate(const SymmetricTensor<rank, dim, Expression> &symbol_tensor,
- const Expression & op)
+ const Expression &op)
{
return internal::tensor_diff_scalar(symbol_tensor, op);
}
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
differentiate(const SymmetricTensor<rank, dim, Expression> &symbol_tensor,
- const Tensor<0, dim, Expression> & op)
+ const Tensor<0, dim, Expression> &op)
{
return internal::tensor_diff_scalar(symbol_tensor, op);
}
template <int rank_1, int rank_2, int dim>
Tensor<rank_1 + rank_2, dim, Expression>
- differentiate(const Tensor<rank_1, dim, Expression> & symbol_tensor,
+ differentiate(const Tensor<rank_1, dim, Expression> &symbol_tensor,
const SymmetricTensor<rank_2, dim, Expression> &op)
{
return internal::tensor_diff_tensor(symbol_tensor, op);
template <int rank_1, int rank_2, int dim>
Tensor<rank_1 + rank_2, dim, Expression>
differentiate(const SymmetricTensor<rank_1, dim, Expression> &symbol_tensor,
- const Tensor<rank_2, dim, Expression> & op)
+ const Tensor<rank_2, dim, Expression> &op)
{
return internal::tensor_diff_tensor(symbol_tensor, op);
}
class TensorType>
void
set_tensor_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const TensorType<rank, dim, SymbolicType> &symbol_tensor,
- const TensorType<rank, dim, ValueType> & value_tensor)
+ const TensorType<rank, dim, ValueType> &value_tensor)
{
TensorType<rank, dim, Expression> out;
for (unsigned int i = 0; i < out.n_independent_components; ++i)
template <typename SymbolicType, typename ValueType, int dim>
void
set_tensor_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const SymmetricTensor<4, dim, SymbolicType> &symbol_tensor,
- const SymmetricTensor<4, dim, ValueType> & value_tensor)
+ const SymmetricTensor<4, dim, ValueType> &value_tensor)
{
SymmetricTensor<4, dim, Expression> out;
for (unsigned int i = 0;
int dim,
typename SymbolicType>
void
- add_to_symbol_map(types::substitution_map & symbol_map,
+ add_to_symbol_map(types::substitution_map &symbol_map,
const Tensor<rank, dim, SymbolicType> &symbol_tensor)
{
// Call the above function
typename SymbolicType>
void
add_to_symbol_map(
- types::substitution_map & symbol_map,
+ types::substitution_map &symbol_map,
const SymmetricTensor<rank, dim, SymbolicType> &symbol_tensor)
{
// Call the above function
template <int rank, int dim, typename SymbolicType, typename ValueType>
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const Tensor<rank, dim, SymbolicType> &symbol_tensor,
- const Tensor<rank, dim, ValueType> & value_tensor)
+ const Tensor<rank, dim, ValueType> &value_tensor)
{
internal::set_tensor_value_in_symbol_map(substitution_map,
symbol_tensor,
template <int rank, int dim, typename SymbolicType, typename ValueType>
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const SymmetricTensor<rank, dim, SymbolicType> &symbol_tensor,
- const SymmetricTensor<rank, dim, ValueType> & value_tensor)
+ const SymmetricTensor<rank, dim, ValueType> &value_tensor)
{
internal::set_tensor_value_in_symbol_map(substitution_map,
symbol_tensor,
types::substitution_map
make_substitution_map(
const Tensor<rank, dim, ExpressionType> &symbol_tensor,
- const Tensor<rank, dim, ValueType> & value_tensor)
+ const Tensor<rank, dim, ValueType> &value_tensor)
{
types::substitution_map substitution_map;
add_to_substitution_map(substitution_map, symbol_tensor, value_tensor);
types::substitution_map
make_substitution_map(
const SymmetricTensor<rank, dim, ExpressionType> &symbol_tensor,
- const SymmetricTensor<rank, dim, ValueType> & value_tensor)
+ const SymmetricTensor<rank, dim, ValueType> &value_tensor)
{
types::substitution_map substitution_map;
add_to_substitution_map(substitution_map, symbol_tensor, value_tensor);
std::vector<std::pair<ExpressionType, ValueType>>
make_tensor_entries_for_substitution_map(
const TensorType<rank, dim, ExpressionType> &symbol_tensor,
- const TensorType<rank, dim, ValueType> & value_tensor)
+ const TensorType<rank, dim, ValueType> &value_tensor)
{
std::vector<std::pair<ExpressionType, ValueType>> symbol_values;
for (unsigned int i = 0; i < symbol_tensor.n_independent_components;
std::vector<std::pair<ExpressionType, ValueType>>
make_tensor_entries_for_substitution_map(
const Tensor<0, dim, ExpressionType> &symbol_tensor,
- const Tensor<0, dim, ValueType> & value_tensor)
+ const Tensor<0, dim, ValueType> &value_tensor)
{
const ExpressionType &expression = symbol_tensor;
- const ValueType & value = value_tensor;
+ const ValueType &value = value_tensor;
return {std::make_pair(expression, value)};
}
std::vector<std::pair<ExpressionType, ValueType>>
make_tensor_entries_for_substitution_map(
const SymmetricTensor<4, dim, ExpressionType> &symbol_tensor,
- const SymmetricTensor<4, dim, ValueType> & value_tensor)
+ const SymmetricTensor<4, dim, ValueType> &value_tensor)
{
std::vector<std::pair<ExpressionType, ValueType>> symbol_values;
for (unsigned int i = 0;
typename ValueType>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const Tensor<rank, dim, ExpressionType> &symbol_tensor,
- const Tensor<rank, dim, ValueType> & value_tensor)
+ const Tensor<rank, dim, ValueType> &value_tensor)
{
add_to_substitution_map<ignore_invalid_symbols>(
substitution_map,
typename ValueType>
void
add_to_substitution_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const SymmetricTensor<rank, dim, ExpressionType> &symbol_tensor,
- const SymmetricTensor<rank, dim, ValueType> & value_tensor)
+ const SymmetricTensor<rank, dim, ValueType> &value_tensor)
{
add_to_substitution_map<ignore_invalid_symbols>(
substitution_map,
TensorType<rank, dim, Expression>
substitute_tensor(
const TensorType<rank, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map)
+ const types::substitution_map &substitution_map)
{
TensorType<rank, dim, Expression> out;
for (unsigned int i = 0; i < out.n_independent_components; ++i)
template <int dim>
Tensor<0, dim, Expression>
substitute_tensor(const Tensor<0, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map)
+ const types::substitution_map &substitution_map)
{
const Expression &expression = expression_tensor;
return substitute(expression, substitution_map);
SymmetricTensor<4, dim, Expression>
substitute_tensor(
const SymmetricTensor<4, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map)
+ const types::substitution_map &substitution_map)
{
SymmetricTensor<4, dim, Expression> out;
for (unsigned int i = 0;
TensorType<rank, dim, ValueType>
substitute_and_evaluate_tensor(
const TensorType<rank, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map)
+ const types::substitution_map &substitution_map)
{
TensorType<rank, dim, ValueType> out;
for (unsigned int i = 0; i < out.n_independent_components; ++i)
Tensor<0, dim, ValueType>
substitute_and_evaluate_tensor(
const Tensor<0, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map)
+ const types::substitution_map &substitution_map)
{
const Expression &expression = expression_tensor;
return substitute_and_evaluate<ValueType>(expression, substitution_map);
SymmetricTensor<4, dim, ValueType>
substitute_and_evaluate_tensor(
const SymmetricTensor<4, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map)
+ const types::substitution_map &substitution_map)
{
SymmetricTensor<4, dim, ValueType> out;
for (unsigned int i = 0;
template <int rank, int dim>
Tensor<rank, dim, Expression>
substitute(const Tensor<rank, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map)
+ const types::substitution_map &substitution_map)
{
return internal::substitute_tensor(expression_tensor, substitution_map);
}
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
substitute(const SymmetricTensor<rank, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map)
+ const types::substitution_map &substitution_map)
{
return internal::substitute_tensor(expression_tensor, substitution_map);
}
Tensor<rank, dim, ValueType>
substitute_and_evaluate(
const Tensor<rank, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map)
+ const types::substitution_map &substitution_map)
{
return internal::substitute_and_evaluate_tensor<ValueType>(
expression_tensor, substitution_map);
SymmetricTensor<rank, dim, ValueType>
substitute_and_evaluate(
const SymmetricTensor<rank, dim, Expression> &expression_tensor,
- const types::substitution_map & substitution_map)
+ const types::substitution_map &substitution_map)
{
return internal::substitute_and_evaluate_tensor<ValueType>(
expression_tensor, substitution_map);
template <typename StreamType>
StreamType &
print_substitution_map(
- StreamType & stream,
+ StreamType &stream,
const SD::types::substitution_map &symbol_value_map);
} // namespace Utilities
template <typename StreamType>
StreamType &
print_substitution_map(
- StreamType & stream,
+ StreamType &stream,
const SD::types::substitution_map &symbol_value_map)
{
for (const auto &entry : symbol_value_map)
*/
CellDataTransfer(
const parallel::distributed::Triangulation<dim, spacedim>
- & triangulation,
+ &triangulation,
const bool transfer_variable_size_data = false,
const std::function<std::vector<value_type>(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const value_type parent_value)> refinement_strategy =
&dealii::AdaptationStrategies::Refinement::
preserve<dim, spacedim, value_type>,
const std::function<value_type(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const std::vector<value_type> &children_values)> coarsening_strategy =
&dealii::AdaptationStrategies::Coarsening::
check_equality<dim, spacedim, value_type>);
cell_iterator &cell,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator>
- & data_range,
+ &data_range,
std::vector<VectorType *> &all_out);
};
} // namespace distributed
const bool transfer_variable_size_data,
const std::function<std::vector<value_type>(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const value_type parent_value)> refinement_strategy,
const std::function<value_type(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const std::vector<value_type> &children_values)> coarsening_strategy)
: triangulation(&triangulation, typeid(*this).name())
, transfer_variable_size_data(transfer_variable_size_data)
cell_iterator &cell,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator>
- & data_range,
+ &data_range,
std::vector<VectorType *> &all_out)
{
std::vector<value_type> cell_data;
* cell's weight during load balancing.
*/
CellWeights(const DoFHandler<dim, spacedim> &dof_handler,
- const WeightingFunction & weighting_function);
+ const WeightingFunction &weighting_function);
/**
* Destructor.
*/
void
reinit(const DoFHandler<dim, spacedim> &dof_handler,
- const WeightingFunction & weighting_function);
+ const WeightingFunction &weighting_function);
/**
* Converts a @p weighting_function to a different type that qualifies as
weighting_callback(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator &cell,
const CellStatus status,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const parallel::TriangulationBase<dim, spacedim> &triangulation,
- const WeightingFunction & weighting_function);
+ const WeightingFunction &weighting_function);
};
} // namespace parallel
*/
void
prepare_for_coarsening_and_refinement(
- const VectorType & in,
+ const VectorType &in,
const unsigned int fe_nothing_index);
/**
* AffineConstraints after refinement.
*/
void
- interpolate(const Number & new_value,
+ interpolate(const Number &new_value,
const AffineConstraints<Number> &affine_constraints,
- VectorType & out);
+ VectorType &out);
private:
/**
* triangulation.
*/
virtual void
- create_triangulation(const std::vector<Point<spacedim>> & vertices,
+ create_triangulation(const std::vector<Point<spacedim>> &vertices,
const std::vector<dealii::CellData<dim>> &cells,
const SubCellData &subcelldata) override;
set_partitioner(
const std::function<void(dealii::Triangulation<dim, spacedim> &,
const unsigned int)> &partitioner,
- const TriangulationDescription::Settings & settings);
+ const TriangulationDescription::Settings &settings);
/**
* Register a partitioner, which is used within the method
void
set_partitioner(
const RepartitioningPolicyTools::Base<dim, spacedim> &partitioner,
- const TriangulationDescription::Settings & settings);
+ const TriangulationDescription::Settings &settings);
/**
* Execute repartitioning and use the partitioner attached by the
*/
template <typename number>
number
- compute_threshold(const dealii::Vector<number> & criteria,
+ compute_threshold(const dealii::Vector<number> &criteria,
const std::pair<double, double> &global_min_and_max,
const types::global_cell_index n_target_cells,
const MPI_Comm mpi_communicator);
*/
template <typename number>
number
- compute_threshold(const dealii::Vector<number> & criteria,
+ compute_threshold(const dealii::Vector<number> &criteria,
const std::pair<double, double> &global_min_and_max,
const double target_error,
const MPI_Comm mpi_communicator);
void
refine_and_coarsen_fixed_number(
dealii::Triangulation<dim, spacedim> &tria,
- const dealii::Vector<Number> & criteria,
+ const dealii::Vector<Number> &criteria,
const double top_fraction_of_cells,
const double bottom_fraction_of_cells,
const types::global_cell_index max_n_cells =
void
refine_and_coarsen_fixed_fraction(
dealii::Triangulation<dim, spacedim> &tria,
- const dealii::Vector<Number> & criteria,
+ const dealii::Vector<Number> &criteria,
const double top_fraction_of_error,
const double bottom_fraction_of_error,
const VectorTools::NormType norm_type = VectorTools::NormType::L1_norm);
static void (&quadrant_childrenv)(const types<2>::quadrant *q,
types<2>::quadrant c[]);
- static int (&quadrant_overlaps_tree)(types<2>::tree * tree,
+ static int (&quadrant_overlaps_tree)(types<2>::tree *tree,
const types<2>::quadrant *q);
static void (&quadrant_set_morton)(types<2>::quadrant *quadrant,
static int (&quadrant_ancestor_id)(const types<2>::quadrant *q,
int level);
- static int (&comm_find_owner)(types<2>::forest * p4est,
+ static int (&comm_find_owner)(types<2>::forest *p4est,
const types<2>::locidx which_tree,
const types<2>::quadrant *q,
const int guess);
types<2>::topidx num_vertices,
types<2>::topidx num_trees,
types<2>::topidx num_corners,
- const double * vertices,
+ const double *vertices,
const types<2>::topidx *ttv,
const types<2>::topidx *ttt,
- const int8_t * ttf,
+ const int8_t *ttf,
const types<2>::topidx *ttc,
const types<2>::topidx *coff,
const types<2>::topidx *ctt,
- const int8_t * ctc);
+ const int8_t *ctc);
static void (&connectivity_join_faces)(types<2>::connectivity *conn,
types<2>::topidx tree_left,
int fill_uniform,
std::size_t data_size,
p4est_init_t init_fn,
- void * user_pointer);
+ void *user_pointer);
static types<2>::forest *(©_forest)(types<2>::forest *input,
int copy_data);
p4est_coarsen_t coarsen_fn,
p4est_init_t init_fn);
- static void (&balance)(types<2>::forest * p4est,
+ static void (&balance)(types<2>::forest *p4est,
types<2>::balance_type btype,
p4est_init_t init_fn);
int partition_for_coarsening,
p4est_weight_t weight_fn);
- static void (&save)(const char * filename,
+ static void (&save)(const char *filename,
types<2>::forest *p4est,
int save_data);
int load_data,
int autopartition,
int broadcasthead,
- void * user_pointer,
+ void *user_pointer,
types<2>::connectivity **p4est);
- static int (&connectivity_save)(const char * filename,
+ static int (&connectivity_save)(const char *filename,
types<2>::connectivity *connectivity);
static int (&connectivity_is_valid)(types<2>::connectivity *connectivity);
- static types<2>::connectivity *(&connectivity_load)(const char * filename,
+ static types<2>::connectivity *(&connectivity_load)(const char *filename,
std::size_t *length);
static unsigned int (&checksum)(types<2>::forest *p4est);
p4est_geometry_t *,
const char *baseName);
- static types<2>::ghost *(&ghost_new)(types<2>::forest * p4est,
+ static types<2>::ghost *(&ghost_new)(types<2>::forest *p4est,
types<2>::balance_type btype);
static void (&ghost_destroy)(types<2>::ghost *ghost);
static void (&reset_data)(types<2>::forest *p4est,
std::size_t data_size,
p4est_init_t init_fn,
- void * user_pointer);
+ void *user_pointer);
static std::size_t (&forest_memory_used)(types<2>::forest *p4est);
template <int spacedim>
static void
iterate(dealii::internal::p4est::types<2>::forest *parallel_forest,
- dealii::internal::p4est::types<2>::ghost * parallel_ghost,
- void * user_data);
+ dealii::internal::p4est::types<2>::ghost *parallel_ghost,
+ void *user_data);
static constexpr unsigned int max_level = P4EST_MAXLEVEL;
const types<2>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const void * src_data,
+ void *dest_data,
+ const void *src_data,
std::size_t data_size);
static types<2>::transfer_context *(&transfer_fixed_begin)(
const types<2>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const void * src_data,
+ void *dest_data,
+ const void *src_data,
std::size_t data_size);
static void (&transfer_fixed_end)(types<2>::transfer_context *tc);
const types<2>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const int * dest_sizes,
- const void * src_data,
- const int * src_sizes);
+ void *dest_data,
+ const int *dest_sizes,
+ const void *src_data,
+ const int *src_sizes);
static types<2>::transfer_context *(&transfer_custom_begin)(
const types<2>::gloidx *dest_gfq,
const types<2>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const int * dest_sizes,
- const void * src_data,
- const int * src_sizes);
+ void *dest_data,
+ const int *dest_sizes,
+ const void *src_data,
+ const int *src_sizes);
static void (&transfer_custom_end)(types<2>::transfer_context *tc);
# ifdef P4EST_SEARCH_LOCAL
static void (&search_partition)(
- types<2>::forest * forest,
+ types<2>::forest *forest,
int call_post,
types<2>::search_partition_callback quadrant_fn,
types<2>::search_partition_callback point_fn,
- sc_array_t * points);
+ sc_array_t *points);
# endif
static void (&quadrant_coord_to_vertex)(
- types<2>::connectivity * connectivity,
+ types<2>::connectivity *connectivity,
types<2>::topidx treeid,
types<2>::quadrant_coord x,
types<2>::quadrant_coord y,
static void (&quadrant_childrenv)(const types<3>::quadrant *q,
types<3>::quadrant c[]);
- static int (&quadrant_overlaps_tree)(types<3>::tree * tree,
+ static int (&quadrant_overlaps_tree)(types<3>::tree *tree,
const types<3>::quadrant *q);
static void (&quadrant_set_morton)(types<3>::quadrant *quadrant,
static int (&quadrant_ancestor_id)(const types<3>::quadrant *q,
int level);
- static int (&comm_find_owner)(types<3>::forest * p4est,
+ static int (&comm_find_owner)(types<3>::forest *p4est,
const types<3>::locidx which_tree,
const types<3>::quadrant *q,
const int guess);
types<3>::topidx num_trees,
types<3>::topidx num_edges,
types<3>::topidx num_corners,
- const double * vertices,
+ const double *vertices,
const types<3>::topidx *ttv,
const types<3>::topidx *ttt,
- const int8_t * ttf,
+ const int8_t *ttf,
const types<3>::topidx *tte,
const types<3>::topidx *eoff,
const types<3>::topidx *ett,
- const int8_t * ete,
+ const int8_t *ete,
const types<3>::topidx *ttc,
const types<3>::topidx *coff,
const types<3>::topidx *ctt,
- const int8_t * ctc);
+ const int8_t *ctc);
static void (&connectivity_join_faces)(types<3>::connectivity *conn,
types<3>::topidx tree_left,
int fill_uniform,
std::size_t data_size,
p8est_init_t init_fn,
- void * user_pointer);
+ void *user_pointer);
static types<3>::forest *(©_forest)(types<3>::forest *input,
int copy_data);
p8est_coarsen_t coarsen_fn,
p8est_init_t init_fn);
- static void (&balance)(types<3>::forest * p8est,
+ static void (&balance)(types<3>::forest *p8est,
types<3>::balance_type btype,
p8est_init_t init_fn);
int partition_for_coarsening,
p8est_weight_t weight_fn);
- static void (&save)(const char * filename,
+ static void (&save)(const char *filename,
types<3>::forest *p4est,
int save_data);
int load_data,
int autopartition,
int broadcasthead,
- void * user_pointer,
+ void *user_pointer,
types<3>::connectivity **p4est);
- static int (&connectivity_save)(const char * filename,
+ static int (&connectivity_save)(const char *filename,
types<3>::connectivity *connectivity);
static int (&connectivity_is_valid)(types<3>::connectivity *connectivity);
- static types<3>::connectivity *(&connectivity_load)(const char * filename,
+ static types<3>::connectivity *(&connectivity_load)(const char *filename,
std::size_t *length);
static unsigned int (&checksum)(types<3>::forest *p8est);
static void (&vtk_write_file)(types<3>::forest *p8est,
p8est_geometry_t *,
const char *baseName);
- static types<3>::ghost *(&ghost_new)(types<3>::forest * p4est,
+ static types<3>::ghost *(&ghost_new)(types<3>::forest *p4est,
types<3>::balance_type btype);
static void (&ghost_destroy)(types<3>::ghost *ghost);
static void (&reset_data)(types<3>::forest *p4est,
std::size_t data_size,
p8est_init_t init_fn,
- void * user_pointer);
+ void *user_pointer);
static std::size_t (&forest_memory_used)(types<3>::forest *p4est);
const types<3>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const void * src_data,
+ void *dest_data,
+ const void *src_data,
std::size_t data_size);
static types<3>::transfer_context *(&transfer_fixed_begin)(
const types<3>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const void * src_data,
+ void *dest_data,
+ const void *src_data,
std::size_t data_size);
static void (&transfer_fixed_end)(types<3>::transfer_context *tc);
const types<3>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const int * dest_sizes,
- const void * src_data,
- const int * src_sizes);
+ void *dest_data,
+ const int *dest_sizes,
+ const void *src_data,
+ const int *src_sizes);
static types<3>::transfer_context *(&transfer_custom_begin)(
const types<3>::gloidx *dest_gfq,
const types<3>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const int * dest_sizes,
- const void * src_data,
- const int * src_sizes);
+ void *dest_data,
+ const int *dest_sizes,
+ const void *src_data,
+ const int *src_sizes);
static void (&transfer_custom_end)(types<3>::transfer_context *tc);
# ifdef P4EST_SEARCH_LOCAL
static void (&search_partition)(
- types<3>::forest * forest,
+ types<3>::forest *forest,
int call_post,
types<3>::search_partition_callback quadrant_fn,
types<3>::search_partition_callback point_fn,
- sc_array_t * points);
+ sc_array_t *points);
# endif
static void (&quadrant_coord_to_vertex)(
- types<3>::connectivity * connectivity,
+ types<3>::connectivity *connectivity,
types<3>::topidx treeid,
types<3>::quadrant_coord x,
types<3>::quadrant_coord y,
*/
virtual void
create_triangulation(const std::vector<Point<spacedim>> &vertices,
- const std::vector<CellData<dim>> & cells,
+ const std::vector<CellData<dim>> &cells,
const SubCellData &subcelldata) override;
/**
template <int dim, int spacedim>
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
template <class Archive>
- void Triangulation<dim, spacedim>::load(Archive & ar,
+ void Triangulation<dim, spacedim>::load(Archive &ar,
const unsigned int version)
{
dealii::Triangulation<dim, spacedim>::load(ar, version);
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator>
- & data_range,
+ &data_range,
std::vector<VectorType *> &all_out,
- VectorType & valence);
+ VectorType &valence);
/**
*/
virtual void
create_triangulation(const std::vector<Point<spacedim>> &vertices,
- const std::vector<CellData<dim>> & cells,
+ const std::vector<CellData<dim>> &cells,
const SubCellData &subcelldata) override;
/**
DoFAccessor(const Triangulation<dim, spacedim> *tria,
const int level,
const int index,
- const DoFHandler<dim, spacedim> * dof_handler);
+ const DoFHandler<dim, spacedim> *dof_handler);
/**
* Copy constructor.
* This iterator can only be called for one-dimensional triangulations.
*/
DoFAccessor(
- const Triangulation<1, spacedim> * tria,
+ const Triangulation<1, spacedim> *tria,
const typename TriaAccessor<0, 1, spacedim>::VertexKind vertex_kind,
const unsigned int vertex_index,
- const DoFHandler<1, spacedim> * dof_handler);
+ const DoFHandler<1, spacedim> *dof_handler);
/**
* Constructor. This constructor exists in order to maintain interface
* semantic sense, and we generate an exception when such an object is
* actually generated.
*/
- DoFInvalidAccessor(const void * parent = nullptr,
+ DoFInvalidAccessor(const void *parent = nullptr,
const int level = -1,
const int index = -1,
const AccessorData *local_data = nullptr);
void
get_dof_values(
const AffineConstraints<typename InputVector::value_type> &constraints,
- const InputVector & values,
+ const InputVector &values,
ForwardIterator local_values_begin,
ForwardIterator local_values_end) const;
template <class OutputVector, typename number>
void
set_dof_values(const Vector<number> &local_values,
- OutputVector & values) const;
+ OutputVector &values) const;
/**
* Return the interpolation of the given finite element function to the
void
get_interpolated_dof_values(
const ReadVector<Number> &values,
- Vector<Number> & interpolated_values,
+ Vector<Number> &interpolated_values,
const types::fe_index fe_index = numbers::invalid_fe_index) const;
/**
void
set_dof_values_by_interpolation(
const Vector<number> &local_values,
- OutputVector & values,
+ OutputVector &values,
const types::fe_index fe_index = numbers::invalid_fe_index,
const bool perform_check = false) const;
void
distribute_local_to_global_by_interpolation(
const Vector<number> &local_values,
- OutputVector & values,
+ OutputVector &values,
const types::fe_index fe_index = numbers::invalid_fe_index) const;
/**
template <typename number, typename OutputVector>
void
distribute_local_to_global(const Vector<number> &local_source,
- OutputVector & global_destination) const;
+ OutputVector &global_destination) const;
/**
* Distribute a local (cell based) vector in iterator format to a global one
void
distribute_local_to_global(ForwardIterator local_source_begin,
ForwardIterator local_source_end,
- OutputVector & global_destination) const;
+ OutputVector &global_destination) const;
/**
* Distribute a local (cell based) vector in iterator format to a global one
const AffineConstraints<typename OutputVector::value_type> &constraints,
ForwardIterator local_source_begin,
ForwardIterator local_source_end,
- OutputVector & global_destination) const;
+ OutputVector &global_destination) const;
/**
* This function does much the same as the
template <typename number, typename OutputMatrix, typename OutputVector>
void
distribute_local_to_global(const FullMatrix<number> &local_matrix,
- const Vector<number> & local_vector,
- OutputMatrix & global_matrix,
- OutputVector & global_vector) const;
+ const Vector<number> &local_vector,
+ OutputMatrix &global_matrix,
+ OutputVector &global_vector) const;
/**
* @}
const Triangulation<dim, spacedim> *tria,
const int level,
const int index,
- const DoFHandler<dim, spacedim> * dof_handler)
+ const DoFHandler<dim, spacedim> *dof_handler)
: dealii::internal::DoFAccessorImplementation::
Inheritance<structdim, dim, spacedim>::BaseClass(tria, level, index)
, dof_handler(const_cast<DoFHandler<dim, spacedim> *>(dof_handler))
const types::fe_index fe_index,
const unsigned int local_index,
const std::integral_constant<int, structdim> &,
- GlobalIndexType & global_index,
+ GlobalIndexType &global_index,
const DoFPProcessor &process)
{
Assert(structdim == dim || obj_level == 0, ExcNotImplemented());
typename DoFProcessor,
typename DoFMapping>
static DEAL_II_ALWAYS_INLINE void
- process_object(const DoFHandler<dim, spacedim> & dof_handler,
+ process_object(const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int obj_level,
const unsigned int obj_index,
const types::fe_index fe_index,
- const DoFMapping & mapping,
+ const DoFMapping &mapping,
const std::integral_constant<int, structdim> &dd,
types::global_dof_index *&dof_indices_ptr,
- const DoFProcessor & process)
+ const DoFProcessor &process)
{
Assert(structdim == dim || obj_level == 0, ExcNotImplemented());
*/
template <int dim, int spacedim, int structdim>
static void
- set_dof_index(const DoFHandler<dim, spacedim> & dof_handler,
+ set_dof_index(const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int obj_level,
const unsigned int obj_index,
const types::fe_index fe_index,
*/
template <int dim, int spacedim, int structdim>
static types::global_dof_index
- get_dof_index(const DoFHandler<dim, spacedim> & dof_handler,
+ get_dof_index(const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int obj_level,
const unsigned int obj_index,
const types::fe_index fe_index,
template <typename InputVector, typename ForwardIterator>
static void
- extract_subvector_to(const InputVector & values,
+ extract_subvector_to(const InputVector &values,
const types::global_dof_index *cache,
const types::global_dof_index *cache_end,
ForwardIterator local_values_begin)
static void
extract_subvector_to(
const LinearAlgebra::TpetraWrappers::Vector<Number> &values,
- const types::global_dof_index * cache_begin,
- const types::global_dof_index * cache_end,
+ const types::global_dof_index *cache_begin,
+ const types::global_dof_index *cache_end,
ForwardIterator local_values_begin)
{
std::vector<unsigned int> sorted_indices_pos =
static unsigned int
n_dof_indices(
const dealii::DoFAccessor<structdim, dim, spacedim, level_dof_access>
- & accessor,
+ &accessor,
const types::fe_index fe_index_,
const bool count_level_dofs)
{
static void
process_dof_indices(
const dealii::DoFAccessor<structdim, dim, spacedim, level_dof_access>
- & accessor,
+ &accessor,
const DoFIndicesType &const_dof_indices,
const types::fe_index fe_index_,
- const DoFOperation & dof_operation,
- const DoFProcessor & dof_processor,
+ const DoFOperation &dof_operation,
+ const DoFProcessor &dof_processor,
const bool count_level_dofs)
{
const types::fe_index fe_index =
process_vertex_dofs(DoFHandler<dim, spacedim> &dof_handler,
const unsigned int vertex_index,
const types::fe_index fe_index,
- types::global_dof_index *& dof_indices_ptr,
- const DoFProcessor & dof_processor) const
+ types::global_dof_index *&dof_indices_ptr,
+ const DoFProcessor &dof_processor) const
{
process_object(
dof_handler,
const unsigned int obj_level,
const unsigned int obj_index,
const types::fe_index fe_index,
- const DoFMapping & mapping,
+ const DoFMapping &mapping,
const std::integral_constant<int, structdim>,
types::global_dof_index *&dof_indices_ptr,
- const DoFProcessor & dof_processor) const
+ const DoFProcessor &dof_processor) const
{
process_object(
dof_handler,
const unsigned int vertex_index,
const types::fe_index,
types::global_dof_index *&dof_indices_ptr,
- const DoFProcessor & dof_processor) const
+ const DoFProcessor &dof_processor) const
{
const unsigned int n_indices =
dof_handler.get_fe(0).template n_dofs_per_object<0>();
const unsigned int,
const unsigned int obj_index,
const types::fe_index fe_index,
- const DoFMapping & mapping,
+ const DoFMapping &mapping,
const std::integral_constant<int, structdim>,
types::global_dof_index *&dof_indices_ptr,
- const DoFProcessor & dof_processor) const
+ const DoFProcessor &dof_processor) const
{
const unsigned int n_indices =
dof_handler.get_fe(0).template n_dofs_per_object<structdim>();
static void
get_dof_indices(
const dealii::DoFAccessor<structdim, dim, spacedim, level_dof_access>
- & accessor,
+ &accessor,
std::vector<types::global_dof_index> &dof_indices,
const types::fe_index fe_index)
{
static void
set_dof_indices(
const dealii::DoFAccessor<structdim, dim, spacedim, level_dof_access>
- & accessor,
+ &accessor,
const std::vector<types::global_dof_index> &dof_indices,
const types::fe_index fe_index)
{
static void
get_mg_dof_indices(
const dealii::DoFAccessor<structdim, dim, spacedim, level_dof_access>
- & accessor,
+ &accessor,
const int level,
std::vector<types::global_dof_index> &dof_indices,
const types::fe_index fe_index)
static void
set_mg_dof_indices(
const dealii::DoFAccessor<structdim, dim, spacedim, level_dof_access>
- & accessor,
+ &accessor,
const int level,
const std::vector<types::global_dof_index> &dof_indices,
const types::fe_index fe_index)
const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<dim>>
&,
const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<dim>>
- & mg_faces,
+ &mg_faces,
const unsigned int obj_index,
const types::fe_index fe_index,
const unsigned int local_index,
const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<3>>
&,
const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<3>>
- & mg_faces,
+ &mg_faces,
const unsigned int obj_index,
const types::fe_index fe_index,
const unsigned int local_index,
template <int spacedim, bool level_dof_access>
inline DoFAccessor<0, 1, spacedim, level_dof_access>::DoFAccessor(
- const Triangulation<1, spacedim> * tria,
+ const Triangulation<1, spacedim> *tria,
const typename TriaAccessor<0, 1, spacedim>::VertexKind vertex_kind,
const unsigned int vertex_index,
- const DoFHandler<1, spacedim> * dof_handler)
+ const DoFHandler<1, spacedim> *dof_handler)
: BaseClass(tria, vertex_kind, vertex_index)
, dof_handler(const_cast<DoFHandler<1, spacedim> *>(dof_handler))
{}
const Triangulation<1, spacedim> *tria,
const int level,
const int index,
- const DoFHandler<1, spacedim> * dof_handler)
+ const DoFHandler<1, spacedim> *dof_handler)
// This is the constructor signature for "ordinary" (non-vertex)
// accessors and we shouldn't be calling it altogether. But it is also
// the constructor that the default-constructor of TriaRawIterator
DoFCellAccessor(const Triangulation<dimension_, space_dimension_> *tria,
const int level,
const int index,
- const AccessorData * local_data)
+ const AccessorData *local_data)
: DoFAccessor<dimension_, dimension_, space_dimension_, level_dof_access>(
tria,
level,
inline void
DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::get_dof_values(
const InputVector &values,
- Vector<number> & local_values) const
+ Vector<number> &local_values) const
{
get_dof_values(values, local_values.begin(), local_values.end());
}
inline void
DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::get_dof_values(
const AffineConstraints<typename InputVector::value_type> &constraints,
- const InputVector & values,
+ const InputVector &values,
ForwardIterator local_values_begin,
ForwardIterator local_values_end) const
{
inline void
DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::set_dof_values(
const Vector<number> &local_values,
- OutputVector & values) const
+ OutputVector &values) const
{
Assert(this->is_artificial() == false,
ExcMessage("Can't ask for DoF indices on artificial cells."));
inline void
DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
distribute_local_to_global(const Vector<number> &local_source,
- OutputVector & global_destination) const
+ OutputVector &global_destination) const
{
this->distribute_local_to_global(local_source.begin(),
local_source.end(),
DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
distribute_local_to_global(ForwardIterator local_source_begin,
ForwardIterator local_source_end,
- OutputVector & global_destination) const
+ OutputVector &global_destination) const
{
Assert(this->dof_handler != nullptr,
(typename std::decay_t<decltype(*this)>::ExcInvalidObject()));
const AffineConstraints<typename OutputVector::value_type> &constraints,
ForwardIterator local_source_begin,
ForwardIterator local_source_end,
- OutputVector & global_destination) const
+ OutputVector &global_destination) const
{
Assert(this->dof_handler != nullptr,
(typename std::decay_t<decltype(*this)>::ExcInvalidObject()));
inline void
DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
distribute_local_to_global(const FullMatrix<number> &local_source,
- OutputMatrix & global_destination) const
+ OutputMatrix &global_destination) const
{
Assert(this->dof_handler != nullptr,
(typename std::decay_t<decltype(*this)>::ExcInvalidObject()));
inline void
DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
distribute_local_to_global(const FullMatrix<number> &local_matrix,
- const Vector<number> & local_vector,
- OutputMatrix & global_matrix,
- OutputVector & global_vector) const
+ const Vector<number> &local_vector,
+ OutputMatrix &global_matrix,
+ OutputVector &global_vector) const
{
Assert(this->dof_handler != nullptr,
(typename std::decay_t<decltype(*this)>::ExcInvalidObject()));
*/
template <int dim, int spacedim>
void
- component_wise(DoFHandler<dim, spacedim> & dof_handler,
+ component_wise(DoFHandler<dim, spacedim> &dof_handler,
const std::vector<unsigned int> &target_component =
std::vector<unsigned int>());
*/
template <int dim, int spacedim>
void
- component_wise(DoFHandler<dim, spacedim> & dof_handler,
+ component_wise(DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const std::vector<unsigned int> &target_component =
std::vector<unsigned int>());
template <int dim, int spacedim, typename CellIterator>
types::global_dof_index
compute_component_wise(std::vector<types::global_dof_index> &new_dof_indices,
- const CellIterator & start,
+ const CellIterator &start,
const std_cxx20::type_identity_t<CellIterator> &end,
const std::vector<unsigned int> &target_component,
const bool is_level_operation);
template <int dim, int spacedim, class ITERATOR, class ENDITERATOR>
types::global_dof_index
compute_block_wise(std::vector<types::global_dof_index> &new_dof_indices,
- const ITERATOR & start,
- const ENDITERATOR & end,
+ const ITERATOR &start,
+ const ENDITERATOR &end,
bool is_level_operation);
/**
compute_cell_wise(
std::vector<types::global_dof_index> &renumbering,
std::vector<types::global_dof_index> &inverse_renumbering,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const std::vector<typename DoFHandler<dim, spacedim>::active_cell_iterator>
&cell_order);
compute_cell_wise(
std::vector<types::global_dof_index> &renumbering,
std::vector<types::global_dof_index> &inverse_renumbering,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const std::vector<typename DoFHandler<dim, spacedim>::level_cell_iterator>
&cell_order);
void
compute_downstream(std::vector<types::global_dof_index> &new_dof_indices,
std::vector<types::global_dof_index> &reverse,
- const DoFHandler<dim, spacedim> & dof_handler,
- const Tensor<1, spacedim> & direction,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const Tensor<1, spacedim> &direction,
const bool dof_wise_renumbering);
/**
void
compute_downstream(std::vector<types::global_dof_index> &new_dof_indices,
std::vector<types::global_dof_index> &reverse,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
- const Tensor<1, spacedim> & direction,
+ const Tensor<1, spacedim> &direction,
const bool dof_wise_renumbering);
/**
template <int dim, int spacedim>
void
clockwise_dg(DoFHandler<dim, spacedim> &dof_handler,
- const Point<spacedim> & center,
+ const Point<spacedim> ¢er,
const bool counter = false);
/**
void
clockwise_dg(DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
- const Point<spacedim> & center,
+ const Point<spacedim> ¢er,
const bool counter = false);
/**
template <int dim, int spacedim>
void
compute_clockwise_dg(std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler,
- const Point<spacedim> & center,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const Point<spacedim> ¢er,
const bool counter);
/**
template <int dim, int spacedim>
void
sort_selected_dofs_back(DoFHandler<dim, spacedim> &dof_handler,
- const std::vector<bool> & selected_dofs);
+ const std::vector<bool> &selected_dofs);
/**
* Sort those degrees of freedom which are tagged with @p true in the @p
template <int dim, int spacedim>
void
sort_selected_dofs_back(DoFHandler<dim, spacedim> &dof_handler,
- const std::vector<bool> & selected_dofs,
+ const std::vector<bool> &selected_dofs,
const unsigned int level);
/**
void
compute_sort_selected_dofs_back(
std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler,
- const std::vector<bool> & selected_dofs);
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const std::vector<bool> &selected_dofs);
/**
* This function computes the renumbering vector on each level needed by the
void
compute_sort_selected_dofs_back(
std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler,
- const std::vector<bool> & selected_dofs,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const std::vector<bool> &selected_dofs,
const unsigned int level);
/**
template <int dim, int spacedim>
void
compute_random(std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler);
+ const DoFHandler<dim, spacedim> &dof_handler);
/**
* Compute the renumbering vector needed by the random() function. Same
template <int dim, int spacedim>
void
compute_random(std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level);
/**
template <int dim, int spacedim>
void
compute_subdomain_wise(std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler);
+ const DoFHandler<dim, spacedim> &dof_handler);
/**
* @}
void
compute_support_point_wise(
std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler);
+ const DoFHandler<dim, spacedim> &dof_handler);
/**
* @}
typename VectorizedArrayType>
void
matrix_free_data_locality(
- DoFHandler<dim, spacedim> & dof_handler,
+ DoFHandler<dim, spacedim> &dof_handler,
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free);
/**
template <int dim, int spacedim, typename Number, typename AdditionalDataType>
void
matrix_free_data_locality(
- DoFHandler<dim, spacedim> & dof_handler,
+ DoFHandler<dim, spacedim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const AdditionalDataType & matrix_free_additional_data);
+ const AdditionalDataType &matrix_free_additional_data);
/**
* Compute the renumbering vector needed by the matrix_free_data_locality()
typename VectorizedArrayType>
std::vector<types::global_dof_index>
compute_matrix_free_data_locality(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free);
/**
compute_matrix_free_data_locality(
const DoFHandler<dim, spacedim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const AdditionalDataType & matrix_free_additional_data);
+ const AdditionalDataType &matrix_free_additional_data);
/**
* @}
Table<2, Coupling>
dof_couplings_from_component_couplings(
const FiniteElement<dim, spacedim> &fe,
- const Table<2, Coupling> & component_couplings);
+ const Table<2, Coupling> &component_couplings);
/**
* Same function as above for a collection of finite elements, returning a
std::vector<Table<2, Coupling>>
dof_couplings_from_component_couplings(
const hp::FECollection<dim, spacedim> &fe,
- const Table<2, Coupling> & component_couplings);
+ const Table<2, Coupling> &component_couplings);
/** @} */
/**
void
make_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof_handler,
- SparsityPatternBase & sparsity_pattern,
+ SparsityPatternBase &sparsity_pattern,
const AffineConstraints<number> &constraints = {},
const bool keep_constrained_dofs = true,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id);
void
make_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof_handler,
- const Table<2, Coupling> & coupling,
- SparsityPatternBase & sparsity_pattern,
+ const Table<2, Coupling> &coupling,
+ SparsityPatternBase &sparsity_pattern,
const AffineConstraints<number> &constraints = {},
const bool keep_constrained_dofs = true,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id);
void
make_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_row,
const DoFHandler<dim, spacedim> &dof_col,
- SparsityPatternBase & sparsity);
+ SparsityPatternBase &sparsity);
/**
* Compute which entries of a matrix built on the given @p dof_handler may
template <int dim, int spacedim>
void
make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_handler,
- SparsityPatternBase & sparsity_pattern);
+ SparsityPatternBase &sparsity_pattern);
/**
* This function does essentially the same as the other
void
make_flux_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof_handler,
- SparsityPatternBase & sparsity_pattern,
+ SparsityPatternBase &sparsity_pattern,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs = true,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id);
void
make_flux_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
- SparsityPatternBase & sparsity,
- const Table<2, Coupling> & cell_integrals_mask,
- const Table<2, Coupling> & face_integrals_mask,
+ SparsityPatternBase &sparsity,
+ const Table<2, Coupling> &cell_integrals_mask,
+ const Table<2, Coupling> &face_integrals_mask,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id);
void
make_flux_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
- const Table<2, Coupling> & couplings,
- const Table<2, Coupling> & face_couplings,
+ const Table<2, Coupling> &couplings,
+ const Table<2, Coupling> &face_couplings,
const types::subdomain_id subdomain_id,
const std::function<
bool(const typename DoFHandler<dim, spacedim>::active_cell_iterator &,
template <int dim, int spacedim>
void
make_boundary_sparsity_pattern(
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparsityPatternBase & sparsity_pattern);
+ SparsityPatternBase &sparsity_pattern);
/**
* This function is a variation of the previous
make_boundary_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_ids,
+ &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparsityPatternBase & sparsity);
+ SparsityPatternBase &sparsity);
/**
* @}
template <int dim, int spacedim, typename number>
void
make_hanging_node_constraints(const DoFHandler<dim, spacedim> &dof_handler,
- AffineConstraints<number> & constraints);
+ AffineConstraints<number> &constraints);
/**
* This function is used when different variables in a problem are
template <int dim, int spacedim>
void
compute_intergrid_constraints(
- const DoFHandler<dim, spacedim> & coarse_grid,
+ const DoFHandler<dim, spacedim> &coarse_grid,
const unsigned int coarse_component,
- const DoFHandler<dim, spacedim> & fine_grid,
+ const DoFHandler<dim, spacedim> &fine_grid,
const unsigned int fine_component,
const InterGridMap<DoFHandler<dim, spacedim>> &coarse_to_fine_grid_map,
- AffineConstraints<double> & constraints);
+ AffineConstraints<double> &constraints);
/**
template <int dim, int spacedim>
void
compute_intergrid_transfer_representation(
- const DoFHandler<dim, spacedim> & coarse_grid,
+ const DoFHandler<dim, spacedim> &coarse_grid,
const unsigned int coarse_component,
- const DoFHandler<dim, spacedim> & fine_grid,
+ const DoFHandler<dim, spacedim> &fine_grid,
const unsigned int fine_component,
const InterGridMap<DoFHandler<dim, spacedim>> &coarse_to_fine_grid_map,
std::vector<std::map<types::global_dof_index, float>>
template <typename FaceIterator, typename number>
void
make_periodicity_constraints(
- const FaceIterator & face_1,
+ const FaceIterator &face_1,
const std_cxx20::type_identity_t<FaceIterator> &face_2,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask = {},
+ AffineConstraints<number> &constraints,
+ const ComponentMask &component_mask = {},
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false,
- const FullMatrix<double> & matrix = FullMatrix<double>(),
+ const FullMatrix<double> &matrix = FullMatrix<double>(),
const std::vector<unsigned int> &first_vector_components =
std::vector<unsigned int>(),
const number periodicity_factor = 1.);
make_periodicity_constraints(
const std::vector<GridTools::PeriodicFacePair<
typename DoFHandler<dim, spacedim>::cell_iterator>> &periodic_faces,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask = {},
+ AffineConstraints<number> &constraints,
+ const ComponentMask &component_mask = {},
const std::vector<unsigned int> &first_vector_components =
std::vector<unsigned int>(),
const number periodicity_factor = 1.);
const types::boundary_id b_id1,
const types::boundary_id b_id2,
const unsigned int direction,
- AffineConstraints<number> & constraints,
+ AffineConstraints<number> &constraints,
const ComponentMask &component_mask = {},
const number periodicity_factor = 1.);
make_periodicity_constraints(const DoFHandler<dim, spacedim> &dof_handler,
const types::boundary_id b_id,
const unsigned int direction,
- AffineConstraints<number> & constraints,
+ AffineConstraints<number> &constraints,
const ComponentMask &component_mask = {},
const number periodicity_factor = 1.);
template <int dim, int spacedim>
IndexSet
extract_dofs(const DoFHandler<dim, spacedim> &dof_handler,
- const ComponentMask & component_mask);
+ const ComponentMask &component_mask);
/**
* This function is the equivalent to the DoFTools::extract_dofs() functions
template <int dim, int spacedim>
IndexSet
extract_dofs(const DoFHandler<dim, spacedim> &dof_handler,
- const BlockMask & block_mask);
+ const BlockMask &block_mask);
/**
* Do the same thing as the corresponding extract_dofs() function for one
void
extract_level_dofs(const unsigned int level,
const DoFHandler<dim, spacedim> &dof,
- const ComponentMask & component_mask,
- std::vector<bool> & selected_dofs);
+ const ComponentMask &component_mask,
+ std::vector<bool> &selected_dofs);
/**
* Do the same thing as the corresponding extract_dofs() function for one
void
extract_level_dofs(const unsigned int level,
const DoFHandler<dim, spacedim> &dof,
- const BlockMask & component_mask,
- std::vector<bool> & selected_dofs);
+ const BlockMask &component_mask,
+ std::vector<bool> &selected_dofs);
/**
* Extract all degrees of freedom which are at the boundary and belong to
*/
template <int dim, int spacedim>
IndexSet
- extract_boundary_dofs(const DoFHandler<dim, spacedim> & dof_handler,
- const ComponentMask & component_mask = {},
+ extract_boundary_dofs(const DoFHandler<dim, spacedim> &dof_handler,
+ const ComponentMask &component_mask = {},
const std::set<types::boundary_id> &boundary_ids = {});
/**
template <int dim, int spacedim>
void
extract_dofs_with_support_on_boundary(
- const DoFHandler<dim, spacedim> & dof_handler,
- const ComponentMask & component_mask,
- std::vector<bool> & selected_dofs,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const ComponentMask &component_mask,
+ std::vector<bool> &selected_dofs,
const std::set<types::boundary_id> &boundary_ids =
std::set<types::boundary_id>());
const DoFHandler<dim, spacedim> &dof_handler,
const std::function<
bool(const typename DoFHandler<dim, spacedim>::active_cell_iterator &)>
- & predicate,
+ &predicate,
const AffineConstraints<number> &constraints = {});
/**
template <int dim, int spacedim>
void
extract_constant_modes(const DoFHandler<dim, spacedim> &dof_handler,
- const ComponentMask & component_mask,
- std::vector<std::vector<bool>> & constant_modes);
+ const ComponentMask &component_mask,
+ std::vector<std::vector<bool>> &constant_modes);
/** @} */
/**
map_boundary_to_bulk_dof_iterators(
const std::map<typename Triangulation<dim - 1, spacedim>::cell_iterator,
typename Triangulation<dim, spacedim>::face_iterator>
- & c1_to_c0,
- const DoFHandler<dim, spacedim> & c0_dh,
+ &c1_to_c0,
+ const DoFHandler<dim, spacedim> &c0_dh,
const DoFHandler<dim - 1, spacedim> &c1_dh);
/**
void
extract_subdomain_dofs(const DoFHandler<dim, spacedim> &dof_handler,
const types::subdomain_id subdomain_id,
- std::vector<bool> & selected_dofs);
+ std::vector<bool> &selected_dofs);
/**
* Extract the set of global DoF indices that are active on the current
template <int dim, int spacedim>
void
extract_locally_active_dofs(const DoFHandler<dim, spacedim> &dof_handler,
- IndexSet & dof_set);
+ IndexSet &dof_set);
/**
* Same function as above but for a certain (multigrid-)level.
void
extract_locally_active_level_dofs(
const DoFHandler<dim, spacedim> &dof_handler,
- IndexSet & dof_set,
+ IndexSet &dof_set,
const unsigned int level);
/**
template <int dim, int spacedim>
void
extract_locally_relevant_dofs(const DoFHandler<dim, spacedim> &dof_handler,
- IndexSet & dof_set);
+ IndexSet &dof_set);
/**
* Extract the set of locally owned DoF indices for each component within the
extract_locally_relevant_level_dofs(
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
- IndexSet & dof_set);
+ IndexSet &dof_set);
/**
*/
template <int dim, int spacedim>
void
- get_subdomain_association(const DoFHandler<dim, spacedim> & dof_handler,
+ get_subdomain_association(const DoFHandler<dim, spacedim> &dof_handler,
std::vector<types::subdomain_id> &subdomain);
/**
count_dofs_with_subdomain_association(
const DoFHandler<dim, spacedim> &dof_handler,
const types::subdomain_id subdomain,
- std::vector<unsigned int> & n_dofs_on_subdomain);
+ std::vector<unsigned int> &n_dofs_on_subdomain);
/**
* Return a set of indices that denotes the degrees of freedom that live on
*/
template <int dim, int spacedim>
void
- make_cell_patches(SparsityPattern & block_list,
+ make_cell_patches(SparsityPattern &block_list,
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
- const std::vector<bool> & selected_dofs = {},
+ const std::vector<bool> &selected_dofs = {},
const types::global_dof_index offset = 0);
/**
*/
template <int dim, int spacedim>
std::vector<unsigned int>
- make_vertex_patches(SparsityPattern & block_list,
+ make_vertex_patches(SparsityPattern &block_list,
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const bool interior_dofs_only,
*/
template <int dim, int spacedim>
std::vector<unsigned int>
- make_vertex_patches(SparsityPattern & block_list,
+ make_vertex_patches(SparsityPattern &block_list,
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const BlockMask &exclude_boundary_dofs = BlockMask(),
*/
template <int dim, int spacedim>
void
- make_child_patches(SparsityPattern & block_list,
+ make_child_patches(SparsityPattern &block_list,
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const bool interior_dofs_only,
*/
template <int dim, int spacedim>
void
- make_single_patch(SparsityPattern & block_list,
+ make_single_patch(SparsityPattern &block_list,
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const bool interior_dofs_only = false);
template <int dim, int spacedim>
DEAL_II_DEPRECATED void
get_active_fe_indices(const DoFHandler<dim, spacedim> &dof_handler,
- std::vector<unsigned int> & active_fe_indices);
+ std::vector<unsigned int> &active_fe_indices);
/**
* Count how many degrees of freedom live on a set of cells (i.e., a patch)
*/
template <int dim, int spacedim>
void
- map_dof_to_boundary_indices(const DoFHandler<dim, spacedim> & dof_handler,
+ map_dof_to_boundary_indices(const DoFHandler<dim, spacedim> &dof_handler,
std::vector<types::global_dof_index> &mapping);
/**
*/
template <int dim, int spacedim>
void
- map_dof_to_boundary_indices(const DoFHandler<dim, spacedim> & dof_handler,
+ map_dof_to_boundary_indices(const DoFHandler<dim, spacedim> &dof_handler,
const std::set<types::boundary_id> &boundary_ids,
std::vector<types::global_dof_index> &mapping);
*/
template <int dim, int spacedim>
void
- map_dofs_to_support_points(const Mapping<dim, spacedim> & mapping,
+ map_dofs_to_support_points(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- std::vector<Point<spacedim>> & support_points,
- const ComponentMask & mask = {});
+ std::vector<Point<spacedim>> &support_points,
+ const ComponentMask &mask = {});
/**
* Same as the previous function but for the hp-case.
void
map_dofs_to_support_points(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- std::vector<Point<spacedim>> & support_points,
- const ComponentMask & mask = {});
+ const DoFHandler<dim, spacedim> &dof_handler,
+ std::vector<Point<spacedim>> &support_points,
+ const ComponentMask &mask = {});
/**
* This function is a version of the above map_dofs_to_support_points
*/
template <int dim, int spacedim>
std::map<types::global_dof_index, Point<spacedim>>
- map_dofs_to_support_points(const Mapping<dim, spacedim> & mapping,
+ map_dofs_to_support_points(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const ComponentMask & mask = {});
+ const ComponentMask &mask = {});
/**
* Same as the previous function but for the hp-case.
std::map<types::global_dof_index, Point<spacedim>>
map_dofs_to_support_points(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const ComponentMask & mask = {});
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const ComponentMask &mask = {});
/**
* A version of the function of same name that returns the map via its third
template <int dim, int spacedim>
DEAL_II_DEPRECATED void
map_dofs_to_support_points(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
std::map<types::global_dof_index, Point<spacedim>> &support_points,
- const ComponentMask & mask = {});
+ const ComponentMask &mask = {});
/**
* A version of the function of same name that returns the map via its third
template <int dim, int spacedim>
DEAL_II_DEPRECATED void
map_dofs_to_support_points(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
std::map<types::global_dof_index, Point<spacedim>> &support_points,
- const ComponentMask & mask = {});
+ const ComponentMask &mask = {});
/**
template <int dim, int spacedim, class Comp>
void
map_support_points_to_dofs(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
std::map<Point<spacedim>, types::global_dof_index, Comp>
&point_to_index_map);
template <int dim, int spacedim, typename Number>
void
distribute_cell_to_dof_vector(const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & cell_data,
- Vector<double> & dof_data,
+ const Vector<Number> &cell_data,
+ Vector<double> &dof_data,
const unsigned int component = 0);
template <int spacedim>
void
write_gnuplot_dof_support_point_info(
- std::ostream & out,
+ std::ostream &out,
const std::map<types::global_dof_index, Point<spacedim>> &support_points);
make_zero_boundary_constraints(
const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_id,
- AffineConstraints<number> & zero_boundary_constraints,
- const ComponentMask & component_mask = {});
+ AffineConstraints<number> &zero_boundary_constraints,
+ const ComponentMask &component_mask = {});
/**
* Do the same as the previous function, except do it for all parts of the
void
make_zero_boundary_constraints(
const DoFHandler<dim, spacedim> &dof,
- AffineConstraints<number> & zero_boundary_constraints,
- const ComponentMask & component_mask = {});
+ AffineConstraints<number> &zero_boundary_constraints,
+ const ComponentMask &component_mask = {});
/**
* @}
template <int dim, int spacedim, class Comp>
void
map_support_points_to_dofs(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
std::map<Point<spacedim>, types::global_dof_index, Comp>
&point_to_index_map)
NumberCache::serialize(Archive &ar, const unsigned int /*version*/)
{
ar &n_global_dofs &n_locally_owned_dofs;
- ar & locally_owned_dofs;
- ar & n_locally_owned_dofs_per_processor;
- ar & locally_owned_dofs_per_processor;
+ ar &locally_owned_dofs;
+ ar &n_locally_owned_dofs_per_processor;
+ ar &locally_owned_dofs_per_processor;
}
} // namespace DoFHandlerImplementation
* where each element equals the component mask provided in the single
* element given.
*/
- FiniteElement(const FiniteElementData<dim> & fe_data,
- const std::vector<bool> & restriction_is_additive_flags,
+ FiniteElement(const FiniteElementData<dim> &fe_data,
+ const std::vector<bool> &restriction_is_additive_flags,
const std::vector<ComponentMask> &nonzero_components);
/**
*/
virtual double
shape_value_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const;
/**
*/
virtual Tensor<1, dim>
shape_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const;
/**
*/
virtual Tensor<2, dim>
shape_grad_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const;
/**
*/
virtual Tensor<3, dim>
shape_3rd_derivative_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const;
/**
*/
virtual Tensor<4, dim>
shape_4th_derivative_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const;
/**
* This function returns @p true, if the shape function @p shape_index has
*/
virtual void
get_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix) const;
+ FullMatrix<double> &matrix) const;
/** @} */
/**
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const;
virtual void
get_subface_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const;
/** @} */
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const;
+ std::vector<double> &nodal_values) const;
/** @} */
virtual std::unique_ptr<InternalDataBase>
get_data(const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
dealii::internal::FEValuesImplementation::
FiniteElementRelatedData<dim, spacedim> &output_data) const = 0;
*/
virtual std::unique_ptr<InternalDataBase>
get_face_data(const UpdateFlags update_flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const hp::QCollection<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::
FiniteElementRelatedData<dim, spacedim> &output_data) const;
get_face_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data) const;
get_subface_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const;
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const InternalDataBase &fe_internal,
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data) const;
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
virtual std::size_t
memory_consumption() const override;
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
private:
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
private:
/**
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
*/
virtual void
get_interpolation_matrix(const FiniteElement<dim> &source,
- FullMatrix<double> & matrix) const override;
+ FullMatrix<double> &matrix) const override;
/**
* Return the matrix interpolating from a face of one element to the face
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
*/
virtual double
shape_value_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<1, dim>
shape_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<2, dim>
shape_grad_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const override;
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
virtual std::unique_ptr<FiniteElement<dim, spacedim>>
clone() const override;
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
virtual std::unique_ptr<FiniteElement<dim, spacedim>>
clone() const override;
};
*/
FE_Enriched(const FiniteElement<dim, spacedim> &fe_base,
const FiniteElement<dim, spacedim> &fe_enriched,
- const Function<spacedim> * enrichment_function);
+ const Function<spacedim> *enrichment_function);
/**
* Constructor which only wraps the base FE @p fe_base.
* checks are done by this class that the domains are actually disjoint.
*/
FE_Enriched(
- const FiniteElement<dim, spacedim> * fe_base,
+ const FiniteElement<dim, spacedim> *fe_base,
const std::vector<const FiniteElement<dim, spacedim> *> &fe_enriched,
const std::vector<std::vector<std::function<const Function<spacedim> *(
const typename Triangulation<dim, spacedim>::cell_iterator &)>>>
*/
FE_Enriched(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities,
+ const std::vector<unsigned int> &multiplicities,
const std::vector<std::vector<std::function<const Function<spacedim> *(
const typename Triangulation<dim, spacedim>::cell_iterator &)>>>
&functions);
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_data(
const UpdateFlags flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const override;
typename FiniteElement<dim, spacedim>::InternalDataBase>
get_face_data(
const UpdateFlags update_flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const hp::QCollection<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
get_subface_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const override;
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
void
multiply_by_enrichment(
const Quadrature<dim_1> &quadrature,
- const InternalData & fe_data,
+ const InternalData &fe_data,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data) const;
template <int dim, int spacedim>
bool
find_connection_between_subdomains(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const predicate_function<dim, spacedim> &predicate_1,
const predicate_function<dim, spacedim> &predicate_2);
template <int dim, int spacedim>
unsigned int
color_predicates(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const std::vector<predicate_function<dim, spacedim>> &predicates,
- std::vector<unsigned int> & predicate_colors);
+ std::vector<unsigned int> &predicate_colors);
/**
* Used to construct data members @p cellwise_color_predicate_map and
template <int dim, int spacedim>
void
set_cellwise_color_set_and_fe_index(
- DoFHandler<dim, spacedim> & dof_handler,
+ DoFHandler<dim, spacedim> &dof_handler,
const std::vector<predicate_function<dim, spacedim>> &predicates,
- const std::vector<unsigned int> & predicate_colors,
+ const std::vector<unsigned int> &predicate_colors,
std::map<unsigned int, std::map<unsigned int, unsigned int>>
- & cellwise_color_predicate_map,
+ &cellwise_color_predicate_map,
std::vector<std::set<unsigned int>> &fe_sets);
/**
* belongs to a sub-domain with index (i).
* @param enrichments std::vector of enrichment functions
*/
- Helper(const FiniteElement<dim, spacedim> & fe_base,
- const FiniteElement<dim, spacedim> & fe_enriched,
- const std::vector<predicate_function<dim, spacedim>> & predicates,
+ Helper(const FiniteElement<dim, spacedim> &fe_base,
+ const FiniteElement<dim, spacedim> &fe_enriched,
+ const std::vector<predicate_function<dim, spacedim>> &predicates,
const std::vector<std::shared_ptr<Function<spacedim>>> &enrichments);
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
/**
* Return the matrix interpolating from a face of one element to the face
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<1, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<1, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_data(
const UpdateFlags update_flags,
const Mapping<1, spacedim> &mapping,
- const Quadrature<0> & quadrature,
+ const Quadrature<0> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1,
spacedim>
&output_data) const override
fill_fe_values(
const typename Triangulation<1, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<1> & quadrature,
- const Mapping<1, spacedim> & mapping,
- const typename Mapping<1, spacedim>::InternalDataBase & mapping_internal,
+ const Quadrature<1> &quadrature,
+ const Mapping<1, spacedim> &mapping,
+ const typename Mapping<1, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<1, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<1, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1,
spacedim>
fill_fe_face_values(
const typename Triangulation<1, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<0> & quadrature,
- const Mapping<1, spacedim> & mapping,
- const typename Mapping<1, spacedim>::InternalDataBase & mapping_internal,
+ const hp::QCollection<0> &quadrature,
+ const Mapping<1, spacedim> &mapping,
+ const typename Mapping<1, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<1, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<1, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1,
spacedim>
const typename Triangulation<1, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<0> & quadrature,
- const Mapping<1, spacedim> & mapping,
- const typename Mapping<1, spacedim>::InternalDataBase & mapping_internal,
+ const Quadrature<0> &quadrature,
+ const Mapping<1, spacedim> &mapping,
+ const typename Mapping<1, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<1, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<1, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1,
spacedim>
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
template <class InputVector, class OutputVector>
void
get_local_dof_values(const InputVector &dof_values,
- OutputVector & local_dof_values) const;
+ OutputVector &local_dof_values) const;
};
* sides of the facet). The FEFaceValues objects will be initialized with
* the given @p mapping, @p quadrature, and @p update_flags.
*/
- FEInterfaceValues(const Mapping<dim, spacedim> & mapping,
+ FEInterfaceValues(const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const UpdateFlags update_flags);
/**
* so that different quadrature rules can be assigned to different
* faces.
*/
- FEInterfaceValues(const Mapping<dim, spacedim> & mapping,
+ FEInterfaceValues(const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const UpdateFlags update_flags);
/**
* See the constructor above.
*/
FEInterfaceValues(const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const UpdateFlags update_flags);
/**
*/
FEInterfaceValues(
const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const hp::FECollection<dim, spacedim> & fe_collection,
- const hp::QCollection<dim - 1> & quadrature_collection,
+ const hp::FECollection<dim, spacedim> &fe_collection,
+ const hp::QCollection<dim - 1> &quadrature_collection,
const UpdateFlags update_flags);
/**
*/
template <typename CellIteratorType, typename CellNeighborIteratorType>
void
- reinit(const CellIteratorType & cell,
+ reinit(const CellIteratorType &cell,
const unsigned int face_no,
const unsigned int sub_face_no,
const CellNeighborIteratorType &cell_neighbor,
template <class InputVector>
void
get_jump_in_function_values(
- const InputVector & fe_function,
+ const InputVector &fe_function,
std::vector<typename InputVector::value_type> &values) const;
/**
template <class InputVector>
void
get_average_of_function_values(
- const InputVector & fe_function,
+ const InputVector &fe_function,
std::vector<typename InputVector::value_type> &values) const;
/**
template <int dim, int spacedim>
FEInterfaceValues<dim, spacedim>::FEInterfaceValues(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const UpdateFlags update_flags)
: n_quadrature_points(quadrature.size())
, fe_face_values(nullptr)
template <int dim, int spacedim>
FEInterfaceValues<dim, spacedim>::FEInterfaceValues(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const UpdateFlags update_flags)
: FEInterfaceValues(
fe.reference_cell().template get_default_linear_mapping<dim, spacedim>(),
template <int dim, int spacedim>
FEInterfaceValues<dim, spacedim>::FEInterfaceValues(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const UpdateFlags update_flags)
: n_quadrature_points(quadrature.max_n_quadrature_points())
, fe_face_values(nullptr)
template <int dim, int spacedim>
FEInterfaceValues<dim, spacedim>::FEInterfaceValues(
const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const hp::FECollection<dim, spacedim> & fe_collection,
- const hp::QCollection<dim - 1> & quadrature_collection,
+ const hp::FECollection<dim, spacedim> &fe_collection,
+ const hp::QCollection<dim - 1> &quadrature_collection,
const UpdateFlags update_flags)
: n_quadrature_points(quadrature_collection.max_n_quadrature_points())
, fe_face_values(nullptr)
template <int dim, int spacedim>
FEInterfaceValues<dim, spacedim>::FEInterfaceValues(
const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim - 1> & quadrature_collection,
+ const hp::QCollection<dim - 1> &quadrature_collection,
const UpdateFlags update_flags)
: FEInterfaceValues(fe_collection.get_reference_cell_default_linear_mapping(),
fe_collection,
template <typename CellIteratorType, typename CellNeighborIteratorType>
void
FEInterfaceValues<dim, spacedim>::reinit(
- const CellIteratorType & cell,
+ const CellIteratorType &cell,
const unsigned int face_no,
const unsigned int sub_face_no,
const CellNeighborIteratorType &cell_neighbor,
template <class InputVector>
void
FEInterfaceValues<dim, spacedim>::get_jump_in_function_values(
- const InputVector & fe_function,
+ const InputVector &fe_function,
std::vector<typename InputVector::value_type> &values) const
{
AssertDimension(values.size(), n_quadrature_points);
template <class InputVector>
void
FEInterfaceValues<dim, spacedim>::get_average_of_function_values(
- const InputVector & fe_function,
+ const InputVector &fe_function,
std::vector<typename InputVector::value_type> &values) const
{
AssertDimension(values.size(), n_quadrature_points);
void
Base<dim, spacedim>::get_local_dof_values(
const InputVector &dof_values,
- OutputVector & local_dof_values) const
+ OutputVector &local_dof_values) const
{
const auto &interface_dof_indices =
this->fe_interface->get_interface_dof_indices();
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
/**
* Return a list of constant modes of the element.
*/
virtual double
shape_value_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<1, dim>
shape_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<2, dim>
shape_grad_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
protected:
get_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const override;
fill_fe_values(
const typename Triangulation<dim, dim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, dim> & mapping,
- const typename Mapping<dim, dim>::InternalDataBase & mapping_internal,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, dim> &mapping,
+ const typename Mapping<dim, dim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, dim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, dim>::InternalDataBase &fedata,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, dim>
&data) const override;
fill_fe_face_values(
const typename Triangulation<dim, dim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, dim> & mapping,
- const typename Mapping<dim, dim>::InternalDataBase & mapping_internal,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, dim> &mapping,
+ const typename Mapping<dim, dim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, dim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, dim>::InternalDataBase &fedata,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, dim>
&data) const override;
const typename Triangulation<dim, dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, dim> & mapping,
- const typename Mapping<dim, dim>::InternalDataBase & mapping_internal,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, dim> &mapping,
+ const typename Mapping<dim, dim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, dim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, dim>::InternalDataBase &fedata,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, dim>
&data) const override;
void
fill_edge_values(const typename Triangulation<dim, dim>::cell_iterator &cell,
const Quadrature<dim> &quadrature,
- const InternalData & fedata) const;
+ const InternalData &fedata) const;
/**
* Populates the cell-dependent face-based shape functions on the given
void
fill_face_values(const typename Triangulation<dim, dim>::cell_iterator &cell,
const Quadrature<dim> &quadrature,
- const InternalData & fedata) const;
+ const InternalData &fedata) const;
};
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
get_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const override;
virtual void
get_interpolation_matrix(
const FiniteElement<dim, spacedim> &source_fe,
- FullMatrix<double> & interpolation_matrix) const override;
+ FullMatrix<double> &interpolation_matrix) const override;
/**
* Return the matrix interpolating from a face of one element to the face
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source_fe,
const unsigned int index,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no = 0) const override;
/**
fill_fe_values(
const Triangulation<2, 2>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<2> & quadrature,
- const Mapping<2, 2> & mapping,
- const Mapping<2, 2>::InternalDataBase & mapping_internal,
+ const Quadrature<2> &quadrature,
+ const Mapping<2, 2> &mapping,
+ const Mapping<2, 2>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<2, 2>
- & mapping_data,
+ &mapping_data,
const FiniteElement<2, 2>::InternalDataBase &fe_internal,
internal::FEValuesImplementation::FiniteElementRelatedData<2, 2>
&output_data) const override;
fill_fe_face_values(
const Triangulation<2, 2>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<1> & quadrature,
- const Mapping<2, 2> & mapping,
- const Mapping<2, 2>::InternalDataBase & mapping_internal,
+ const hp::QCollection<1> &quadrature,
+ const Mapping<2, 2> &mapping,
+ const Mapping<2, 2>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<2, 2>
- & mapping_data,
+ &mapping_data,
const InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2, 2>
&output_data) const override;
const Triangulation<2, 2>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<1> & quadrature,
- const Mapping<2, 2> & mapping,
- const Mapping<2, 2>::InternalDataBase & mapping_internal,
+ const Quadrature<1> &quadrature,
+ const Mapping<2, 2> &mapping,
+ const Mapping<2, 2>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<2, 2>
- & mapping_data,
+ &mapping_data,
const InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2, 2>
&output_data) const override;
* Constructor.
*/
FE_Poly(const ScalarPolynomialsBase<dim> &poly_space,
- const FiniteElementData<dim> & fe_data,
- const std::vector<bool> & restriction_is_additive_flags,
+ const FiniteElementData<dim> &fe_data,
+ const std::vector<bool> &restriction_is_additive_flags,
const std::vector<ComponentMask> &nonzero_components);
/**
*/
virtual double
shape_value_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<1, dim>
shape_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<2, dim>
shape_grad_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<3, dim>
shape_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* Return the third derivative of the <tt>component</tt>th vector component
*/
virtual Tensor<3, dim>
shape_3rd_derivative_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<4, dim>
shape_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* Return the fourth derivative of the <tt>component</tt>th vector component
*/
virtual Tensor<4, dim>
shape_4th_derivative_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
get_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const override
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const unsigned int n_q_points) const;
/**
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const unsigned int n_q_points) const;
template <int dim, int spacedim>
FE_Poly<dim, spacedim>::FE_Poly(
const ScalarPolynomialsBase<dim> &poly_space,
- const FiniteElementData<dim> & fe_data,
- const std::vector<bool> & restriction_is_additive_flags,
+ const FiniteElementData<dim> &fe_data,
+ const std::vector<bool> &restriction_is_additive_flags,
const std::vector<ComponentMask> &nonzero_components)
: FiniteElement<dim, spacedim>(fe_data,
restriction_is_additive_flags,
template <int dim, int spacedim>
double
FE_Poly<dim, spacedim>::shape_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
return poly_space->compute_value(i, p);
double
FE_Poly<dim, spacedim>::shape_value_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim, int spacedim>
Tensor<1, dim>
FE_Poly<dim, spacedim>::shape_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
return poly_space->template compute_derivative<1>(i, p);
template <int dim, int spacedim>
Tensor<1, dim>
FE_Poly<dim, spacedim>::shape_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim, int spacedim>
Tensor<2, dim>
FE_Poly<dim, spacedim>::shape_grad_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
return poly_space->template compute_derivative<2>(i, p);
Tensor<2, dim>
FE_Poly<dim, spacedim>::shape_grad_grad_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim, int spacedim>
Tensor<3, dim>
FE_Poly<dim, spacedim>::shape_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
return poly_space->template compute_derivative<3>(i, p);
Tensor<3, dim>
FE_Poly<dim, spacedim>::shape_3rd_derivative_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim, int spacedim>
Tensor<4, dim>
FE_Poly<dim, spacedim>::shape_4th_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
return poly_space->template compute_derivative<4>(i, p);
Tensor<4, dim>
FE_Poly<dim, spacedim>::shape_4th_derivative_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
(void)component;
higher_derivatives_need_correcting(
const Mapping<dim, spacedim> &mapping,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const unsigned int n_q_points,
const UpdateFlags update_flags)
{
FE_Poly<dim, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
FE_Poly<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const unsigned int n_q_points) const
{
for (unsigned int dof = 0; dof < this->n_dofs_per_cell(); ++dof)
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const unsigned int n_q_points) const
{
for (unsigned int dof = 0; dof < this->n_dofs_per_cell(); ++dof)
/**
* Constructor.
*/
- FE_PolyFace(const PolynomialType & poly_space,
+ FE_PolyFace(const PolynomialType &poly_space,
const FiniteElementData<dim> &fe_data,
- const std::vector<bool> & restriction_is_additive_flags);
+ const std::vector<bool> &restriction_is_additive_flags);
/**
* Return the polynomial degree of this finite element, i.e. the value
get_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const override
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
get_face_data(
const UpdateFlags update_flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const hp::QCollection<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
get_subface_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const override
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
template <typename PolynomialType, int dim, int spacedim>
FE_PolyFace<PolynomialType, dim, spacedim>::FE_PolyFace(
- const PolynomialType & poly_space,
+ const PolynomialType &poly_space,
const FiniteElementData<dim> &fe_data,
- const std::vector<bool> & restriction_is_additive_flags)
+ const std::vector<bool> &restriction_is_additive_flags)
: FiniteElement<dim, spacedim>(
fe_data,
restriction_is_additive_flags,
* simply pass a temporary object as the first argument.
*/
FE_PolyTensor(const TensorPolynomialsBase<dim> &polynomials,
- const FiniteElementData<dim> & fe_data,
- const std::vector<bool> & restriction_is_additive_flags,
+ const FiniteElementData<dim> &fe_data,
+ const std::vector<bool> &restriction_is_additive_flags,
const std::vector<ComponentMask> &nonzero_components);
// documentation inherited from the base class
virtual double
shape_value_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
// documentation inherited from the base class
virtual Tensor<1, dim>
shape_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
// documentation inherited from the base class
virtual Tensor<2, dim>
shape_grad_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
protected:
get_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const override
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
* Constructor.
*/
FE_PyramidPoly(const unsigned int degree,
- const internal::GenericDoFsPerObject & dpos,
+ const internal::GenericDoFsPerObject &dpos,
const typename FiniteElementData<dim>::Conformity conformity);
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
};
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
/**
* @copydoc FiniteElement::compare_for_domination()
* Constructor.
*/
FE_Q_Base(const ScalarPolynomialsBase<dim> &poly_space,
- const FiniteElementData<dim> & fe_data,
- const std::vector<bool> & restriction_is_additive_flags);
+ const FiniteElementData<dim> &fe_data,
+ const std::vector<bool> &restriction_is_additive_flags);
/**
* Return the matrix interpolating from the given finite element to the
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
/**
* Return the matrix interpolating from the given finite element to the
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
/**
* Return the matrix interpolating from the given finite element to the
*/
virtual void
get_interpolation_matrix(const FiniteElement<dim> &source,
- FullMatrix<double> & matrix) const override;
+ FullMatrix<double> &matrix) const override;
/**
* Embedding matrix between grids. Only isotropic refinement is supported.
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
/**
* @name Functions to support hp
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
private:
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
/**
* Return a list of constant modes of the element. This method is currently
virtual void
get_face_interpolation_matrix(const FiniteElement<dim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
virtual void
get_subface_interpolation_matrix(
const FiniteElement<dim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
virtual bool
hp_constraints_are_implemented() const override;
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
private:
/**
* case it indicates that the sole component is to be decomposed. For
* vector-valued FEs, a non-default value must be explicitly provided.
*/
- Fourier(const std::vector<unsigned int> & n_coefficients_per_direction,
+ Fourier(const std::vector<unsigned int> &n_coefficients_per_direction,
const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & q_collection,
+ const hp::QCollection<dim> &q_collection,
const unsigned int component = numbers::invalid_unsigned_int);
/**
void
calculate(const dealii::Vector<Number> &local_dof_values,
const unsigned int cell_active_fe_index,
- Table<dim, CoefficientType> & fourier_coefficients);
+ Table<dim, CoefficientType> &fourier_coefficients);
/**
* Return the number of coefficients in each coordinate direction for the
*/
Legendre(const std::vector<unsigned int> &n_coefficients_per_direction,
const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & q_collection,
+ const hp::QCollection<dim> &q_collection,
const unsigned int component = numbers::invalid_unsigned_int);
/**
void
calculate(const dealii::Vector<Number> &local_dof_values,
const unsigned int cell_active_fe_index,
- Table<dim, CoefficientType> & legendre_coefficients);
+ Table<dim, CoefficientType> &legendre_coefficients);
/**
* Return the number of coefficients in each coordinate direction for the
std::pair<std::vector<unsigned int>, std::vector<double>>
process_coefficients(const Table<dim, CoefficientType> &coefficients,
const std::function<std::pair<bool, unsigned int>(
- const TableIndices<dim> &)> & predicate,
+ const TableIndices<dim> &)> &predicate,
const VectorTools::NormType norm_type,
const double smallest_abs_coefficient = 1e-10);
void
fill_map_index(
const Table<dim, CoefficientType> &coefficients,
- const TableIndices<dim> & ind,
+ const TableIndices<dim> &ind,
const std::function<
std::pair<bool, unsigned int>(const TableIndices<dim> &)> &predicate,
std::map<unsigned int, std::vector<CoefficientType>> &pred_to_values)
const Table<1, CoefficientType> &coefficients,
const std::function<
std::pair<bool, unsigned int>(const TableIndices<1> &)> &predicate,
- std::map<unsigned int, std::vector<CoefficientType>> & pred_to_values)
+ std::map<unsigned int, std::vector<CoefficientType>> &pred_to_values)
{
for (unsigned int i = 0; i < coefficients.size(0); ++i)
{
const Table<2, CoefficientType> &coefficients,
const std::function<
std::pair<bool, unsigned int>(const TableIndices<2> &)> &predicate,
- std::map<unsigned int, std::vector<CoefficientType>> & pred_to_values)
+ std::map<unsigned int, std::vector<CoefficientType>> &pred_to_values)
{
for (unsigned int i = 0; i < coefficients.size(0); ++i)
for (unsigned int j = 0; j < coefficients.size(1); ++j)
const Table<3, CoefficientType> &coefficients,
const std::function<
std::pair<bool, unsigned int>(const TableIndices<3> &)> &predicate,
- std::map<unsigned int, std::vector<CoefficientType>> & pred_to_values)
+ std::map<unsigned int, std::vector<CoefficientType>> &pred_to_values)
{
for (unsigned int i = 0; i < coefficients.size(0); ++i)
for (unsigned int j = 0; j < coefficients.size(1); ++j)
FESeries::process_coefficients(
const Table<dim, CoefficientType> &coefficients,
const std::function<std::pair<bool, unsigned int>(const TableIndices<dim> &)>
- & predicate,
+ &predicate,
const VectorTools::NormType norm_type,
const double smallest_abs_coefficient)
{
// finite element collection
unsigned int size = fe_collection->size();
- ar & size;
+ ar &size;
for (unsigned int i = 0; i < size; ++i)
ar &(*fe_collection)[i].get_name();
// the transformation matrices to load.
// mode vector
std::vector<unsigned int> compare_coefficients;
- ar & compare_coefficients;
+ ar &compare_coefficients;
Assert(compare_coefficients == n_coefficients_per_direction,
ExcMessage("A different number of coefficients vector has been used "
"to generate the transformation matrices you are about "
// finite element collection
unsigned int size;
- ar & size;
+ ar &size;
AssertDimension(size, fe_collection->size());
std::string name;
for (unsigned int i = 0; i < size; ++i)
// finite element collection
unsigned int size = fe_collection->size();
- ar & size;
+ ar &size;
for (unsigned int i = 0; i < size; ++i)
ar &(*fe_collection)[i].get_name();
// the transformation matrices to load.
// mode vector
std::vector<unsigned int> compare_coefficients;
- ar & compare_coefficients;
+ ar &compare_coefficients;
Assert(compare_coefficients == n_coefficients_per_direction,
ExcMessage("A different number of coefficients vector has been used "
"to generate the transformation matrices you are about "
// finite element collection
unsigned int size;
- ar & size;
+ ar &size;
AssertDimension(size, fe_collection->size());
std::string name;
for (unsigned int i = 0; i < size; ++i)
*/
FE_SimplexPoly(
const BarycentricPolynomials<dim> polynomials,
- const FiniteElementData<dim> & fe_data,
- const std::vector<Point<dim>> & unit_support_points,
+ const FiniteElementData<dim> &fe_data,
+ const std::vector<Point<dim>> &unit_support_points,
const std::vector<std::vector<Point<dim - 1>>> unit_face_support_points,
- const FullMatrix<double> & interface_constraints);
+ const FullMatrix<double> &interface_constraints);
/**
* Return a list of constant modes of the element. For this element, the
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
const unsigned int subface,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const override;
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
protected:
/**
*/
virtual double
shape_value_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<1, dim>
shape_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<2, dim>
shape_grad_grad_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<3, dim>
shape_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* Return the third derivatives of the @p componentth vector component of
*/
virtual Tensor<3, dim>
shape_3rd_derivative_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual Tensor<4, dim>
shape_4th_derivative(const unsigned int i,
- const Point<dim> & p) const override;
+ const Point<dim> &p) const override;
/**
* Return the fourth derivatives of the @p componentth vector component of
*/
virtual Tensor<4, dim>
shape_4th_derivative_component(const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const override;
/**
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & dof_values) const override;
+ std::vector<double> &dof_values) const override;
/**
* Determine an estimate for the memory consumption (in bytes) of this
get_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const override;
typename FiniteElement<dim, spacedim>::InternalDataBase>
get_face_data(
const UpdateFlags update_flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const hp::QCollection<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
get_subface_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const override;
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
template <class Q_or_QC>
void
compute_fill(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Q_or_QC & quadrature,
+ const Q_or_QC &quadrature,
const CellSimilarity::Similarity cell_similarity,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_data,
auto
promote_to_fe_pair(std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
unsigned int> &&p)
- -> decltype(
- std::forward<std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
- unsigned int>>(p))
+ -> decltype(std::forward<
+ std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
+ unsigned int>>(p))
{
return std::forward<
std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>(
*/
template <int dim, int spacedim>
void
- compute_component_wise(const FiniteElement<dim, spacedim> & fe,
- std::vector<unsigned int> & renumbering,
+ compute_component_wise(const FiniteElement<dim, spacedim> &fe,
+ std::vector<unsigned int> &renumbering,
std::vector<std::vector<unsigned int>> &start_indices);
/**
*/
template <int dim, int spacedim>
void
- compute_block_renumbering(const FiniteElement<dim, spacedim> & fe,
+ compute_block_renumbering(const FiniteElement<dim, spacedim> &fe,
std::vector<types::global_dof_index> &renumbering,
std::vector<types::global_dof_index> &block_data,
bool return_start_indices = true);
void
get_projection_matrix(const FiniteElement<dim, spacedim> &fe1,
const FiniteElement<dim, spacedim> &fe2,
- FullMatrix<number> & matrix);
+ FullMatrix<number> &matrix);
/**
* This is a rather specialized function used during the construction of
template <int dim, typename number, int spacedim>
void
compute_embedding_matrices(
- const FiniteElement<dim, spacedim> & fe,
+ const FiniteElement<dim, spacedim> &fe,
std::vector<std::vector<FullMatrix<number>>> &matrices,
const bool isotropic_only = false,
const double threshold = 1.e-12);
template <int dim, typename number, int spacedim>
void
compute_projection_matrices(
- const FiniteElement<dim, spacedim> & fe,
+ const FiniteElement<dim, spacedim> &fe,
std::vector<std::vector<FullMatrix<number>>> &matrices,
const bool isotropic_only = false);
void
compute_projection_from_quadrature_points_matrix(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & lhs_quadrature,
- const Quadrature<dim> & rhs_quadrature,
- FullMatrix<double> & X);
+ const Quadrature<dim> &lhs_quadrature,
+ const Quadrature<dim> &rhs_quadrature,
+ FullMatrix<double> &X);
/**
* Given a (scalar) local finite element function, compute the matrix that
void
compute_interpolation_to_quadrature_points_matrix(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- FullMatrix<double> & I_q);
+ const Quadrature<dim> &quadrature,
+ FullMatrix<double> &I_q);
/**
* Compute the projection of tensorial (first-order tensor) data stored at
template <int dim>
void
compute_projection_from_quadrature_points(
- const FullMatrix<double> & projection_matrix,
+ const FullMatrix<double> &projection_matrix,
const std::vector<Tensor<1, dim>> &vector_of_tensors_at_qp,
- std::vector<Tensor<1, dim>> & vector_of_tensors_at_nodes);
+ std::vector<Tensor<1, dim>> &vector_of_tensors_at_nodes);
template <int dim>
void
compute_projection_from_quadrature_points(
- const FullMatrix<double> & projection_matrix,
+ const FullMatrix<double> &projection_matrix,
const std::vector<SymmetricTensor<2, dim>> &vector_of_tensors_at_qp,
- std::vector<SymmetricTensor<2, dim>> & vector_of_tensors_at_nodes);
+ std::vector<SymmetricTensor<2, dim>> &vector_of_tensors_at_nodes);
void
compute_projection_from_face_quadrature_points_matrix(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & lhs_quadrature,
- const Quadrature<dim - 1> & rhs_quadrature,
+ const Quadrature<dim - 1> &lhs_quadrature,
+ const Quadrature<dim - 1> &rhs_quadrature,
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const unsigned int face,
- FullMatrix<double> & X);
+ FullMatrix<double> &X);
void
convert_generalized_support_point_values_to_dof_values(
const FiniteElement<dim, spacedim> &finite_element,
- const std::vector<Vector<number>> & support_point_values,
- std::vector<number> & dof_values);
+ const std::vector<Vector<number>> &support_point_values,
+ std::vector<number> &dof_values);
template <int dim, int spacedim, class InVector, class OutVector>
void
interpolate(const DoFHandler<dim, spacedim> &dof1,
- const InVector & u1,
+ const InVector &u1,
const DoFHandler<dim, spacedim> &dof2,
- OutVector & u2);
+ OutVector &u2);
/**
* Compute the interpolation of a the @p dof1-function @p u1 to a @p
template <int dim, int spacedim, class InVector, class OutVector>
void
interpolate(
- const DoFHandler<dim, spacedim> & dof1,
- const InVector & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const DoFHandler<dim, spacedim> &dof1,
+ const InVector &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename OutVector::value_type> &constraints,
- OutVector & u2);
+ OutVector &u2);
/**
* Compute the interpolation of the @p fe1-function @p u1 to a @p
*/
template <int dim, class InVector, class OutVector, int spacedim>
void
- back_interpolate(const DoFHandler<dim, spacedim> & dof1,
- const InVector & u1,
+ back_interpolate(const DoFHandler<dim, spacedim> &dof1,
+ const InVector &u1,
const FiniteElement<dim, spacedim> &fe2,
- OutVector & u1_interpolated);
+ OutVector &u1_interpolated);
/**
* Compute the interpolation of the @p dof1-function @p u1 to a @p
template <int dim, class InVector, class OutVector, int spacedim>
void
back_interpolate(
- const DoFHandler<dim, spacedim> & dof1,
+ const DoFHandler<dim, spacedim> &dof1,
const AffineConstraints<typename OutVector::value_type> &constraints1,
- const InVector & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const InVector &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename OutVector::value_type> &constraints2,
- OutVector & u1_interpolated);
+ OutVector &u1_interpolated);
/**
* Compute $(Id-I_h)z_1$ for a given @p dof1-function $z_1$, where $I_h$ is
*/
template <int dim, class InVector, class OutVector, int spacedim>
void
- interpolation_difference(const DoFHandler<dim, spacedim> & dof1,
- const InVector & z1,
+ interpolation_difference(const DoFHandler<dim, spacedim> &dof1,
+ const InVector &z1,
const FiniteElement<dim, spacedim> &fe2,
- OutVector & z1_difference);
+ OutVector &z1_difference);
/**
* Compute $(Id-I_h)z_1$ for a given @p dof1-function $z_1$, where $I_h$ is
template <int dim, class InVector, class OutVector, int spacedim>
void
interpolation_difference(
- const DoFHandler<dim, spacedim> & dof1,
+ const DoFHandler<dim, spacedim> &dof1,
const AffineConstraints<typename OutVector::value_type> &constraints1,
- const InVector & z1,
- const DoFHandler<dim, spacedim> & dof2,
+ const InVector &z1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename OutVector::value_type> &constraints2,
- OutVector & z1_difference);
+ OutVector &z1_difference);
template <int dim, class InVector, class OutVector, int spacedim>
void
project_dg(const DoFHandler<dim, spacedim> &dof1,
- const InVector & u1,
+ const InVector &u1,
const DoFHandler<dim, spacedim> &dof2,
- OutVector & u2);
+ OutVector &u2);
/**
* Compute the patchwise extrapolation of a @p dof1 function @p z1 to a @p
template <int dim, class InVector, class OutVector, int spacedim>
void
extrapolate(const DoFHandler<dim, spacedim> &dof1,
- const InVector & z1,
+ const InVector &z1,
const DoFHandler<dim, spacedim> &dof2,
- OutVector & z2);
+ OutVector &z2);
/**
* Compute the patchwise extrapolation of a @p dof1 function @p z1 to a @p
template <int dim, class InVector, class OutVector, int spacedim>
void
extrapolate(
- const DoFHandler<dim, spacedim> & dof1,
- const InVector & z1,
- const DoFHandler<dim, spacedim> & dof2,
+ const DoFHandler<dim, spacedim> &dof1,
+ const InVector &z1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename OutVector::value_type> &constraints,
- OutVector & z2);
+ OutVector &z2);
/** @} */
/**
FiniteElementData<dim>
multiply_dof_numbers(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities,
+ const std::vector<unsigned int> &multiplicities,
const bool do_tensor_product = true);
/**
std::vector<bool>
compute_restriction_is_additive_flags(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities);
+ const std::vector<unsigned int> &multiplicities);
/**
* Same as above for an arbitrary number of parameters of type
std::vector<ComponentMask>
compute_nonzero_components(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities,
+ const std::vector<unsigned int> &multiplicities,
const bool do_tensor_product = true);
/**
std::vector<std::pair<std::pair<unsigned int, unsigned int>,
unsigned int>> &system_to_base_table,
std::vector<std::pair<unsigned int, unsigned int>>
- & system_to_component_table,
+ &system_to_component_table,
std::vector<std::pair<std::pair<unsigned int, unsigned int>,
unsigned int>> &component_to_base_table,
- const FiniteElement<dim, spacedim> & finite_element,
+ const FiniteElement<dim, spacedim> &finite_element,
const bool do_tensor_product = true);
/**
std::vector<std::pair<std::pair<unsigned int, unsigned int>,
unsigned int>> &face_system_to_base_table,
std::vector<std::pair<unsigned int, unsigned int>>
- & face_system_to_component_table,
+ &face_system_to_component_table,
const FiniteElement<dim, spacedim> &finite_element,
const bool do_tensor_product = true,
const unsigned int face_no = 0 /*TODO*/);
*/
template <int dim, int spacedim>
void
- add_fe_name(const std::string & name,
+ add_fe_name(const std::string &name,
const FEFactoryBase<dim, spacedim> *factory);
/**
FiniteElementData<dim>
multiply_dof_numbers(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities,
+ const std::vector<unsigned int> &multiplicities,
const bool do_tensor_product)
{
AssertDimension(fes.size(), multiplicities.size());
std::vector<bool>
compute_restriction_is_additive_flags(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities)
+ const std::vector<unsigned int> &multiplicities)
{
AssertDimension(fes.size(), multiplicities.size());
std::vector<ComponentMask>
compute_nonzero_components(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities,
+ const std::vector<unsigned int> &multiplicities,
const bool do_tensor_product)
{
AssertDimension(fes.size(), multiplicities.size());
std::vector<std::pair<std::pair<unsigned int, unsigned int>,
unsigned int>> &system_to_base_table,
std::vector<std::pair<unsigned int, unsigned int>>
- & system_to_component_table,
+ &system_to_component_table,
std::vector<std::pair<std::pair<unsigned int, unsigned int>,
unsigned int>> &component_to_base_table,
- const FiniteElement<dim, spacedim> & fe,
+ const FiniteElement<dim, spacedim> &fe,
const bool do_tensor_product)
{
unsigned int total_index = 0;
std::vector<std::pair<std::pair<unsigned int, unsigned int>,
unsigned int>> &face_system_to_base_table,
std::vector<std::pair<unsigned int, unsigned int>>
- & face_system_to_component_table,
+ &face_system_to_component_table,
const FiniteElement<dim, spacedim> &fe,
const bool do_tensor_product,
const unsigned int face_no)
inline void
gim_forwarder(const FiniteElement<dim, spacedim> &fe1,
const FiniteElement<dim, spacedim> &fe2,
- FullMatrix<double> & interpolation_matrix)
+ FullMatrix<double> &interpolation_matrix)
{
fe2.get_interpolation_matrix(fe1, interpolation_matrix);
}
inline void
gim_forwarder(const FiniteElement<dim, spacedim> &fe1,
const FiniteElement<dim, spacedim> &fe2,
- FullMatrix<number> & interpolation_matrix)
+ FullMatrix<number> &interpolation_matrix)
{
FullMatrix<double> tmp(interpolation_matrix.m(),
interpolation_matrix.n());
template <int dim, int spacedim>
void
- compute_component_wise(const FiniteElement<dim, spacedim> & element,
- std::vector<unsigned int> & renumbering,
+ compute_component_wise(const FiniteElement<dim, spacedim> &element,
+ std::vector<unsigned int> &renumbering,
std::vector<std::vector<unsigned int>> &comp_start)
{
Assert(renumbering.size() == element.n_dofs_per_cell(),
template <int dim, int spacedim>
void
- compute_block_renumbering(const FiniteElement<dim, spacedim> & element,
+ compute_block_renumbering(const FiniteElement<dim, spacedim> &element,
std::vector<types::global_dof_index> &renumbering,
std::vector<types::global_dof_index> &block_data,
bool return_start_indices)
void
get_projection_matrix(const FiniteElement<dim, spacedim> &fe1,
const FiniteElement<dim, spacedim> &fe2,
- FullMatrix<number> & matrix)
+ FullMatrix<number> &matrix)
{
Assert(matrix.m() == fe2.n_dofs_per_cell() &&
matrix.n() == fe1.n_dofs_per_cell(),
compute_embedding_for_shape_function(
const unsigned int i,
const FiniteElement<dim, spacedim> &fe,
- const FEValues<dim, spacedim> & coarse,
- const Householder<double> & H,
- FullMatrix<number> & this_matrix,
+ const FEValues<dim, spacedim> &coarse,
+ const Householder<double> &H,
+ FullMatrix<number> &this_matrix,
const double threshold)
{
const unsigned int n = fe.n_dofs_per_cell();
if (fe.is_primitive())
{
const unsigned int d = fe.system_to_component_index(i).first;
- const double * phi_i = &coarse.shape_value(i, 0);
+ const double *phi_i = &coarse.shape_value(i, 0);
for (unsigned int k = 0; k < nq; ++k)
v_coarse(k * nd + d) = phi_i[k];
void
compute_embedding_matrices_for_refinement_case(
const FiniteElement<dim, spacedim> &fe,
- std::vector<FullMatrix<number>> & matrices,
+ std::vector<FullMatrix<number>> &matrices,
const unsigned int ref_case,
const double threshold)
{
template <int dim, typename number, int spacedim>
void
compute_embedding_matrices(
- const FiniteElement<dim, spacedim> & fe,
+ const FiniteElement<dim, spacedim> &fe,
std::vector<std::vector<FullMatrix<number>>> &matrices,
const bool isotropic_only,
const double threshold)
template <int dim, typename number, int spacedim>
void
compute_projection_matrices(
- const FiniteElement<dim, spacedim> & fe,
+ const FiniteElement<dim, spacedim> &fe,
std::vector<std::vector<FullMatrix<number>>> &matrices,
const bool isotropic_only)
{
const auto compute_one_case =
[&reference_cell, &mapping, &fe, &q_fine, n, nd, nq](
const unsigned int ref_case,
- const FullMatrix<double> & inverse_mass_matrix,
+ const FullMatrix<double> &inverse_mass_matrix,
std::vector<FullMatrix<double>> &matrices) {
const unsigned int nc =
GeometryInfo<dim>::n_children(RefinementCase<dim>(ref_case));
template <int dim, int spacedim>
void
- add_fe_name(const std::string & parameter_name,
+ add_fe_name(const std::string ¶meter_name,
const FEFactoryBase<dim, spacedim> *factory)
{
// Erase everything after the
void
compute_projection_from_quadrature_points_matrix(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & lhs_quadrature,
- const Quadrature<dim> & rhs_quadrature,
- FullMatrix<double> & X)
+ const Quadrature<dim> &lhs_quadrature,
+ const Quadrature<dim> &rhs_quadrature,
+ FullMatrix<double> &X)
{
Assert(fe.n_components() == 1, ExcNotImplemented());
void
compute_interpolation_to_quadrature_points_matrix(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- FullMatrix<double> & I_q)
+ const Quadrature<dim> &quadrature,
+ FullMatrix<double> &I_q)
{
Assert(fe.n_components() == 1, ExcNotImplemented());
Assert(I_q.m() == quadrature.size(), ExcMessage("Wrong matrix size"));
template <int dim>
void
compute_projection_from_quadrature_points(
- const FullMatrix<double> & projection_matrix,
+ const FullMatrix<double> &projection_matrix,
const std::vector<Tensor<1, dim>> &vector_of_tensors_at_qp,
- std::vector<Tensor<1, dim>> & vector_of_tensors_at_nodes)
+ std::vector<Tensor<1, dim>> &vector_of_tensors_at_nodes)
{
// check that the number columns of the projection_matrix
// matches the size of the vector_of_tensors_at_qp
template <int dim>
void
compute_projection_from_quadrature_points(
- const FullMatrix<double> & projection_matrix,
+ const FullMatrix<double> &projection_matrix,
const std::vector<SymmetricTensor<2, dim>> &vector_of_tensors_at_qp,
- std::vector<SymmetricTensor<2, dim>> & vector_of_tensors_at_nodes)
+ std::vector<SymmetricTensor<2, dim>> &vector_of_tensors_at_nodes)
{
// check that the number columns of the projection_matrix
// matches the size of the vector_of_tensors_at_qp
void
compute_projection_from_face_quadrature_points_matrix(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & lhs_quadrature,
- const Quadrature<dim - 1> & rhs_quadrature,
+ const Quadrature<dim - 1> &lhs_quadrature,
+ const Quadrature<dim - 1> &rhs_quadrature,
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const unsigned int face,
- FullMatrix<double> & X)
+ FullMatrix<double> &X)
{
Assert(fe.n_components() == 1, ExcNotImplemented());
Assert(lhs_quadrature.size() > fe.degree,
template <int dim, int spacedim, typename number>
static void
convert_helper(const FiniteElement<dim, spacedim> &finite_element,
- const std::vector<Vector<number>> & support_point_values,
- std::vector<number> & dof_values)
+ const std::vector<Vector<number>> &support_point_values,
+ std::vector<number> &dof_values)
{
static Threads::ThreadLocalStorage<std::vector<Vector<double>>>
double_support_point_values;
template <int dim, int spacedim, typename number>
static void
convert_helper(
- const FiniteElement<dim, spacedim> & finite_element,
+ const FiniteElement<dim, spacedim> &finite_element,
const std::vector<Vector<std::complex<number>>> &support_point_values,
- std::vector<std::complex<number>> & dof_values)
+ std::vector<std::complex<number>> &dof_values)
{
static Threads::ThreadLocalStorage<std::vector<Vector<double>>>
double_support_point_values_real;
template <int dim, int spacedim>
static void
convert_helper(const FiniteElement<dim, spacedim> &finite_element,
- const std::vector<Vector<double>> & support_point_values,
- std::vector<double> & dof_values)
+ const std::vector<Vector<double>> &support_point_values,
+ std::vector<double> &dof_values)
{
finite_element.convert_generalized_support_point_values_to_dof_values(
support_point_values, dof_values);
void
convert_generalized_support_point_values_to_dof_values(
const FiniteElement<dim, spacedim> &finite_element,
- const std::vector<Vector<number>> & support_point_values,
- std::vector<number> & dof_values)
+ const std::vector<Vector<number>> &support_point_values,
+ std::vector<number> &dof_values)
{
AssertDimension(support_point_values.size(),
finite_element.get_generalized_support_points().size());
template <class InVector>
void
- extrapolate_parallel(const InVector & u2_relevant,
+ extrapolate_parallel(const InVector &u2_relevant,
const DoFHandler<dim, spacedim> &dof2,
- OutVector & u2);
+ OutVector &u2);
private:
/**
template <class InVector>
void
compute_all_non_local_data(const DoFHandler<dim, spacedim> &dof2,
- const InVector & u);
+ const InVector &u);
// traverse recursively over
// the cells of this tree and
void
interpolate_recursively(
const typename dealii::internal::p4est::types<dim>::forest &forest,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
+ &p4est_cell,
const InVector &u1,
- OutVector & u2);
+ OutVector &u2);
// get dof values for this
// cell by interpolation
void
get_interpolated_dof_values(
const typename dealii::internal::p4est::types<dim>::forest &forest,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
- const InVector & u,
- Vector<value_type> & interpolated_values,
+ &p4est_cell,
+ const InVector &u,
+ Vector<value_type> &interpolated_values,
std::vector<CellData> &new_needs);
// set dof values for this
set_dof_values_by_interpolation(
const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
+ &p4est_cell,
const Vector<value_type> &interpolated_values,
- OutVector & u);
+ OutVector &u);
// compute all cell_data
// needed from other processes
// this process
void
compute_needs(const DoFHandler<dim, spacedim> &dof2,
- std::vector<CellData> & new_needs);
+ std::vector<CellData> &new_needs);
// traverse over the tree
// and look for patches this
void
traverse_tree_recursively(
const typename dealii::internal::p4est::types<dim>::forest &forest,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
+ &p4est_cell,
std::vector<CellData> &new_needs);
// traverse recursively
void
traverse_patch_recursively(
const typename dealii::internal::p4est::types<dim>::forest &forest,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
+ &p4est_cell,
std::vector<CellData> &new_needs);
// compute dof values of all
template <class InVector>
void
compute_cells(const DoFHandler<dim, spacedim> &dof2,
- const InVector & u,
- std::vector<CellData> & cells_to_compute,
- std::vector<CellData> & computed_cells,
- std::vector<CellData> & new_needs);
+ const InVector &u,
+ std::vector<CellData> &cells_to_compute,
+ std::vector<CellData> &computed_cells,
+ std::vector<CellData> &new_needs);
// traverse over the tree
// and compute cells
void
compute_cells_in_tree_recursively(
const typename dealii::internal::p4est::types<dim>::forest &forest,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
- const InVector & u,
+ &p4est_cell,
+ const InVector &u,
std::vector<CellData> &cells_to_compute,
std::vector<CellData> &computed_cells,
std::vector<CellData> &new_needs);
// and receives a vector of cell_data
void
exchange_data_on_cells(const std::vector<CellData> &cells_to_send,
- std::vector<CellData> & received_cells) const;
+ std::vector<CellData> &received_cells) const;
// add new cell_data to
// the ordered list new_needs
add_new_need(
const typename dealii::internal::p4est::types<dim>::forest &forest,
const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
+ &p4est_cell,
std::vector<CellData> &new_needs);
// binary search in cells_list
// assume that cells_list
// is ordered
static int
- cell_data_search(const CellData & cell_data,
+ cell_data_search(const CellData &cell_data,
const std::vector<CellData> &cells_list);
// insert cell_data into a sorted
// position if cell_data
// not exists already in cells_list
static void
- cell_data_insert(const CellData & cell_data,
+ cell_data_insert(const CellData &cell_data,
std::vector<CellData> &cells_list);
MPI_Comm communicator;
ExtrapolateImplementation<dim, spacedim, OutVector>::
interpolate_recursively(
const typename dealii::internal::p4est::types<dim>::forest &forest,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
+ &p4est_cell,
const InVector &u1,
- OutVector & u2)
+ OutVector &u2)
{
// check if this cell exists in the local p4est
int idx = sc_array_bsearch(
ExtrapolateImplementation<dim, spacedim, OutVector>::
get_interpolated_dof_values(
const typename dealii::internal::p4est::types<dim>::forest &forest,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
- const InVector & u,
- Vector<value_type> & interpolated_values,
+ &p4est_cell,
+ const InVector &u,
+ Vector<value_type> &interpolated_values,
std::vector<CellData> &new_needs)
{
if (dealii_cell->is_active())
set_dof_values_by_interpolation(
const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
+ &p4est_cell,
const Vector<value_type> &local_values,
- OutVector & u)
+ OutVector &u)
{
const FiniteElement<dim, spacedim> &fe =
dealii_cell->get_dof_handler().get_fe();
void
ExtrapolateImplementation<dim, spacedim, OutVector>::compute_needs(
const DoFHandler<dim, spacedim> &dof2,
- std::vector<CellData> & new_needs)
+ std::vector<CellData> &new_needs)
{
const parallel::distributed::Triangulation<dim, spacedim> *tr =
(dynamic_cast<const parallel::distributed::Triangulation<dim, spacedim>
ExtrapolateImplementation<dim, spacedim, OutVector>::
traverse_tree_recursively(
const typename dealii::internal::p4est::types<dim>::forest &forest,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
+ &p4est_cell,
std::vector<CellData> &new_needs)
{
// check if this cell exists in the local p4est
ExtrapolateImplementation<dim, spacedim, OutVector>::
traverse_patch_recursively(
const typename dealii::internal::p4est::types<dim>::forest &forest,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
+ &p4est_cell,
std::vector<CellData> &new_needs)
{
if (dealii_cell->has_children())
void
ExtrapolateImplementation<dim, spacedim, OutVector>::compute_cells(
const DoFHandler<dim, spacedim> &dof2,
- const InVector & u,
- std::vector<CellData> & cells_to_compute,
- std::vector<CellData> & computed_cells,
- std::vector<CellData> & new_needs)
+ const InVector &u,
+ std::vector<CellData> &cells_to_compute,
+ std::vector<CellData> &computed_cells,
+ std::vector<CellData> &new_needs)
{
const parallel::distributed::Triangulation<dim, spacedim> *tr =
(dynamic_cast<const parallel::distributed::Triangulation<dim, spacedim>
ExtrapolateImplementation<dim, spacedim, OutVector>::
compute_cells_in_tree_recursively(
const typename dealii::internal::p4est::types<dim>::forest &forest,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant
- & p4est_cell,
- const InVector & u,
+ &p4est_cell,
+ const InVector &u,
std::vector<CellData> &cells_to_compute,
std::vector<CellData> &computed_cells,
std::vector<CellData> &new_needs)
void
ExtrapolateImplementation<dim, spacedim, OutVector>::exchange_data_on_cells(
const std::vector<CellData> &cells_to_send,
- std::vector<CellData> & received_cells) const
+ std::vector<CellData> &received_cells) const
{
// First figure out where we need to send stuff. Some of the cells
// in the input argument to this function might be destined for
template <int dim, int spacedim, class OutVector>
void
ExtrapolateImplementation<dim, spacedim, OutVector>::add_new_need(
- const typename dealii::internal::p4est::types<dim>::forest & forest,
- const typename dealii::internal::p4est::types<dim>::locidx & tree_index,
- const typename DoFHandler<dim, spacedim>::cell_iterator & dealii_cell,
+ const typename dealii::internal::p4est::types<dim>::forest &forest,
+ const typename dealii::internal::p4est::types<dim>::locidx &tree_index,
+ const typename DoFHandler<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant &p4est_cell,
- std::vector<CellData> & new_needs)
+ std::vector<CellData> &new_needs)
{
const FiniteElement<dim, spacedim> &fe =
dealii_cell->get_dof_handler().get_fe();
template <int dim, int spacedim, class OutVector>
int
ExtrapolateImplementation<dim, spacedim, OutVector>::cell_data_search(
- const CellData & cell_data,
+ const CellData &cell_data,
const std::vector<CellData> &cells_list)
{
typename std::vector<CellData>::const_iterator bound =
template <int dim, int spacedim, class OutVector>
void
ExtrapolateImplementation<dim, spacedim, OutVector>::cell_data_insert(
- const CellData & cell_data,
+ const CellData &cell_data,
std::vector<CellData> &cells_list)
{
// Find the place to insert the cell:
void
ExtrapolateImplementation<dim, spacedim, OutVector>::
compute_all_non_local_data(const DoFHandler<dim, spacedim> &dof2,
- const InVector & u)
+ const InVector &u)
{
std::vector<CellData> cells_we_need, cells_to_compute, received_cells,
received_needs, new_needs, computed_cells, cells_to_send;
template <class InVector>
void
ExtrapolateImplementation<dim, spacedim, OutVector>::extrapolate_parallel(
- const InVector & u2_relevant,
+ const InVector &u2_relevant,
const DoFHandler<dim, spacedim> &dof2,
- OutVector & u2)
+ OutVector &u2)
{
const parallel::distributed::Triangulation<dim, spacedim> *tr =
(dynamic_cast<const parallel::distributed::Triangulation<dim, spacedim>
template <int dim, int spacedim>
void
reinit_distributed(const DoFHandler<dim, spacedim> &dh,
- PETScWrappers::MPI::Vector & vector)
+ PETScWrappers::MPI::Vector &vector)
{
const parallel::distributed::Triangulation<dim, spacedim> *parallel_tria =
dynamic_cast<
template <int dim, int spacedim>
void
reinit_distributed(const DoFHandler<dim, spacedim> &dh,
- TrilinosWrappers::MPI::Vector & vector)
+ TrilinosWrappers::MPI::Vector &vector)
{
const parallel::distributed::Triangulation<dim, spacedim> *parallel_tria =
dynamic_cast<
# ifdef DEAL_II_TRILINOS_WITH_TPETRA
template <int dim, int spacedim, typename Number>
void
- reinit_distributed(const DoFHandler<dim, spacedim> & dh,
+ reinit_distributed(const DoFHandler<dim, spacedim> &dh,
LinearAlgebra::TpetraWrappers::Vector<Number> &vector)
{
const parallel::distributed::Triangulation<dim, spacedim> *parallel_tria =
template <int dim, int spacedim>
void
- reinit_distributed(const DoFHandler<dim, spacedim> & dh,
+ reinit_distributed(const DoFHandler<dim, spacedim> &dh,
LinearAlgebra::EpetraWrappers::Vector &vector)
{
const parallel::distributed::Triangulation<dim, spacedim> *parallel_tria =
template <int dim, int spacedim, typename Number>
void
- reinit_distributed(const DoFHandler<dim, spacedim> & dh,
+ reinit_distributed(const DoFHandler<dim, spacedim> &dh,
LinearAlgebra::distributed::Vector<Number> &vector)
{
const parallel::distributed::Triangulation<dim, spacedim> *parallel_tria =
template <int dim, int spacedim>
void
reinit_ghosted(const DoFHandler<dim, spacedim> &dh,
- PETScWrappers::MPI::Vector & vector)
+ PETScWrappers::MPI::Vector &vector)
{
const parallel::distributed::Triangulation<dim, spacedim> *parallel_tria =
dynamic_cast<
template <int dim, int spacedim>
void
reinit_ghosted(const DoFHandler<dim, spacedim> &dh,
- TrilinosWrappers::MPI::Vector & vector)
+ TrilinosWrappers::MPI::Vector &vector)
{
const parallel::distributed::Triangulation<dim, spacedim> *parallel_tria =
dynamic_cast<
template <int dim, int spacedim, typename Number>
void
- reinit_ghosted(const DoFHandler<dim, spacedim> & dh,
+ reinit_ghosted(const DoFHandler<dim, spacedim> &dh,
LinearAlgebra::distributed::Vector<Number> &vector)
{
const parallel::distributed::Triangulation<dim, spacedim> *parallel_tria =
*/
template <int dim, class InVector, class OutVector, int spacedim>
void
- extrapolate_serial(const InVector & u3,
+ extrapolate_serial(const InVector &u3,
const DoFHandler<dim, spacedim> &dof2,
- OutVector & u2)
+ OutVector &u2)
{
const unsigned int dofs_per_cell = dof2.get_fe().n_dofs_per_cell();
Vector<typename OutVector::value_type> dof_values(dofs_per_cell);
template <int dim, class InVector, class OutVector, int spacedim>
void
extrapolate(const DoFHandler<dim, spacedim> &dof1,
- const InVector & u1,
+ const InVector &u1,
const DoFHandler<dim, spacedim> &dof2,
- OutVector & u2)
+ OutVector &u2)
{
// Forward to the other function using an empty set of
// constraints.
template <int dim, class InVector, class OutVector, int spacedim>
void
extrapolate(
- const DoFHandler<dim, spacedim> & dof1,
- const InVector & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const DoFHandler<dim, spacedim> &dof1,
+ const InVector &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename OutVector::value_type> &constraints,
- OutVector & u2)
+ OutVector &u2)
{
Assert(dof1.get_fe_collection().size() == 1, ExcNotImplemented());
Assert(dof2.get_fe_collection().size() == 1, ExcNotImplemented());
template <int dim, int spacedim, class InVector, class OutVector>
void
interpolate(const DoFHandler<dim, spacedim> &dof1,
- const InVector & u1,
+ const InVector &u1,
const DoFHandler<dim, spacedim> &dof2,
- OutVector & u2)
+ OutVector &u2)
{
AffineConstraints<typename OutVector::value_type> dummy;
dummy.close();
template <int dim, int spacedim, class InVector, class OutVector>
void
interpolate(
- const DoFHandler<dim, spacedim> & dof1,
- const InVector & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const DoFHandler<dim, spacedim> &dof1,
+ const InVector &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename OutVector::value_type> &constraints,
- OutVector & u2)
+ OutVector &u2)
{
Assert(&dof1.get_triangulation() == &dof2.get_triangulation(),
ExcTriangulationMismatch());
template <int dim, class InVector, class OutVector, int spacedim>
void
- back_interpolate(const DoFHandler<dim, spacedim> & dof1,
- const InVector & u1,
+ back_interpolate(const DoFHandler<dim, spacedim> &dof1,
+ const InVector &u1,
const FiniteElement<dim, spacedim> &fe2,
- OutVector & u1_interpolated)
+ OutVector &u1_interpolated)
{
Assert(dof1.get_fe(0).n_components() == fe2.n_components(),
ExcDimensionMismatch(dof1.get_fe(0).n_components(),
template <int dim, int spacedim, class InVector>
std::enable_if_t<is_serial_vector<InVector>::value>
back_interpolate(
- const DoFHandler<dim, spacedim> & dof1,
+ const DoFHandler<dim, spacedim> &dof1,
const AffineConstraints<typename InVector::value_type> &constraints1,
- const InVector & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const InVector &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename InVector::value_type> &constraints2,
- InVector & u1_interpolated)
+ InVector &u1_interpolated)
{
Vector<typename InVector::value_type> u2(dof2.n_dofs());
interpolate(dof1, u1, dof2, constraints2, u2);
back_interpolate(
const DoFHandler<dim, spacedim> &dof1,
const AffineConstraints<PETScWrappers::MPI::Vector::value_type>
- & constraints1,
+ &constraints1,
const PETScWrappers::MPI::Vector &u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<PETScWrappers::MPI::Vector::value_type>
- & constraints2,
+ &constraints2,
PETScWrappers::MPI::Vector &u1_interpolated)
{
// if u1 is a parallel distributed PETSc vector, we create a
const DoFHandler<dim, spacedim> &dof1,
const AffineConstraints<
typename TrilinosWrappers::MPI::Vector::value_type> &constraints1,
- const TrilinosWrappers::MPI::Vector & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const TrilinosWrappers::MPI::Vector &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<
typename TrilinosWrappers::MPI::Vector::value_type> &constraints2,
- TrilinosWrappers::MPI::Vector & u1_interpolated)
+ TrilinosWrappers::MPI::Vector &u1_interpolated)
{
// if u1 is a parallel distributed Trilinos vector, we create a
// vector u2 with based on the sets of locally owned and relevant
const DoFHandler<dim, spacedim> &dof1,
const AffineConstraints<
typename TrilinosWrappers::MPI::BlockVector::value_type> &constraints1,
- const TrilinosWrappers::MPI::BlockVector & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const TrilinosWrappers::MPI::BlockVector &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<
typename TrilinosWrappers::MPI::BlockVector::value_type> &constraints2,
TrilinosWrappers::MPI::BlockVector &u1_interpolated)
template <int dim, int spacedim, typename Number>
void
back_interpolate(
- const DoFHandler<dim, spacedim> & dof1,
- const AffineConstraints<Number> & constraints1,
+ const DoFHandler<dim, spacedim> &dof1,
+ const AffineConstraints<Number> &constraints1,
const LinearAlgebra::distributed::Vector<Number> &u1,
- const DoFHandler<dim, spacedim> & dof2,
- const AffineConstraints<Number> & constraints2,
- LinearAlgebra::distributed::Vector<Number> & u1_interpolated)
+ const DoFHandler<dim, spacedim> &dof2,
+ const AffineConstraints<Number> &constraints2,
+ LinearAlgebra::distributed::Vector<Number> &u1_interpolated)
{
const IndexSet &dof2_locally_owned_dofs = dof2.locally_owned_dofs();
IndexSet dof2_locally_relevant_dofs;
template <int dim, class InVector, class OutVector, int spacedim>
void
back_interpolate(
- const DoFHandler<dim, spacedim> & dof1,
+ const DoFHandler<dim, spacedim> &dof1,
const AffineConstraints<typename OutVector::value_type> &constraints1,
- const InVector & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const InVector &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename OutVector::value_type> &constraints2,
- OutVector & u1_interpolated)
+ OutVector &u1_interpolated)
{
// For discontinuous elements without constraints take the simpler version
// of the back_interpolate function.
template <int dim, class InVector, class OutVector, int spacedim>
void
- interpolation_difference(const DoFHandler<dim, spacedim> & dof1,
- const InVector & u1,
+ interpolation_difference(const DoFHandler<dim, spacedim> &dof1,
+ const InVector &u1,
const FiniteElement<dim, spacedim> &fe2,
- OutVector & u1_difference)
+ OutVector &u1_difference)
{
Assert(dof1.get_fe(0).n_components() == fe2.n_components(),
ExcDimensionMismatch(dof1.get_fe(0).n_components(),
template <int dim, class InVector, class OutVector, int spacedim>
void
interpolation_difference(
- const DoFHandler<dim, spacedim> & dof1,
+ const DoFHandler<dim, spacedim> &dof1,
const AffineConstraints<typename OutVector::value_type> &constraints1,
- const InVector & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const InVector &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename OutVector::value_type> &constraints2,
- OutVector & u1_difference)
+ OutVector &u1_difference)
{
back_interpolate(
dof1, constraints1, u1, dof2, constraints2, u1_difference);
interpolation_difference(
const DoFHandler<dim, spacedim> &dof1,
const AffineConstraints<TrilinosWrappers::MPI::Vector::value_type>
- & constraints1,
+ &constraints1,
const TrilinosWrappers::MPI::Vector &u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<TrilinosWrappers::MPI::Vector::value_type>
- & constraints2,
+ &constraints2,
TrilinosWrappers::MPI::Vector &u1_difference)
{
back_interpolate(
template <int dim, class InVector, class OutVector, int spacedim>
void
interpolation_difference(
- const DoFHandler<dim, spacedim> & dof1,
+ const DoFHandler<dim, spacedim> &dof1,
const AffineConstraints<typename OutVector::value_type> &constraints1,
- const InVector & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const InVector &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename OutVector::value_type> &constraints2,
- OutVector & u1_difference)
+ OutVector &u1_difference)
{
// For discontinuous elements
// without constraints take the
template <int dim, class InVector, class OutVector, int spacedim>
void
project_dg(const DoFHandler<dim, spacedim> &dof1,
- const InVector & u1,
+ const InVector &u1,
const DoFHandler<dim, spacedim> &dof2,
- OutVector & u2)
+ OutVector &u2)
{
Assert(&dof1.get_triangulation() == &dof2.get_triangulation(),
ExcTriangulationMismatch());
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
/**
* This function returns @p true, if the shape function @p shape_index has
*/
virtual void
get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no = 0) const override;
/**
* Constructor. Gets cell independent data from mapping and finite element
* objects, matching the quadrature rule and update flags.
*/
- FEValues(const Mapping<dim, spacedim> & mapping,
+ FEValues(const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const UpdateFlags update_flags);
/**
* @note We require, in contrast to FEFaceValues, that the number of quadrature
* rules in the collection is one.
*/
- FEValues(const Mapping<dim, spacedim> & mapping,
+ FEValues(const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim> & quadrature,
+ const hp::QCollection<dim> &quadrature,
const UpdateFlags update_flags);
/**
* MappingQ(1)) implicitly.
*/
FEValues(const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const UpdateFlags update_flags);
/**
* rules in the collection is one.
*/
FEValues(const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim> & quadrature,
+ const hp::QCollection<dim> &quadrature,
const UpdateFlags update_flags);
/**
*/
FEFaceValuesBase(const unsigned int dofs_per_cell,
const UpdateFlags update_flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature);
+ const Quadrature<dim - 1> &quadrature);
/**
* Like the function above, but taking a collection of quadrature rules. This
*/
FEFaceValuesBase(const unsigned int dofs_per_cell,
const UpdateFlags update_flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & quadrature);
+ const hp::QCollection<dim - 1> &quadrature);
/**
* Boundary form of the transformation of the cell at the <tt>q_point</tt>th
* Constructor. Gets cell independent data from mapping and finite element
* objects, matching the quadrature rule and update flags.
*/
- FEFaceValues(const Mapping<dim, spacedim> & mapping,
+ FEFaceValues(const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const UpdateFlags update_flags);
/**
* the collection only contains a single face quadrature, this quadrature
* rule is use on all faces.
*/
- FEFaceValues(const Mapping<dim, spacedim> & mapping,
+ FEFaceValues(const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const UpdateFlags update_flags);
/**
* MappingQ(1)) implicitly.
*/
FEFaceValues(const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const UpdateFlags update_flags);
/**
* rule is use on all faces.
*/
FEFaceValues(const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const UpdateFlags update_flags);
/**
void
reinit(
const TriaIterator<DoFCellAccessor<dim, spacedim, level_dof_access>> &cell,
- const typename Triangulation<dim, spacedim>::face_iterator & face);
+ const typename Triangulation<dim, spacedim>::face_iterator &face);
/**
* Reinitialize the gradients, Jacobi determinants, etc for the given face
* Constructor. Gets cell independent data from mapping and finite element
* objects, matching the quadrature rule and update flags.
*/
- FESubfaceValues(const Mapping<dim, spacedim> & mapping,
+ FESubfaceValues(const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & face_quadrature,
+ const Quadrature<dim - 1> &face_quadrature,
const UpdateFlags update_flags);
/**
* @note We require, in contrast to FEFaceValues, that the number of quadrature
* rules in the collection is one.
*/
- FESubfaceValues(const Mapping<dim, spacedim> & mapping,
+ FESubfaceValues(const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & face_quadrature,
+ const hp::QCollection<dim - 1> &face_quadrature,
const UpdateFlags update_flags);
/**
* MappingQ(1)) implicitly.
*/
FESubfaceValues(const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & face_quadrature,
+ const Quadrature<dim - 1> &face_quadrature,
const UpdateFlags update_flags);
/**
* rules in the collection is one.
*/
FESubfaceValues(const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & face_quadrature,
+ const hp::QCollection<dim - 1> &face_quadrature,
const UpdateFlags update_flags);
/**
void
reinit(
const TriaIterator<DoFCellAccessor<dim, spacedim, level_dof_access>> &cell,
- const typename Triangulation<dim, spacedim>::face_iterator & face,
+ const typename Triangulation<dim, spacedim>::face_iterator &face,
const typename Triangulation<dim, spacedim>::face_iterator &subface);
/**
FEValuesBase(const unsigned int n_q_points,
const unsigned int dofs_per_cell,
const UpdateFlags update_flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe);
/**
template <typename Number>
void
get_function_values(const ReadVector<Number> &fe_function,
- std::vector<Number> & values) const;
+ std::vector<Number> &values) const;
/**
* This function does the same as the other get_function_values(), but
*/
template <typename Number>
void
- get_function_values(const ReadVector<Number> & fe_function,
+ get_function_values(const ReadVector<Number> &fe_function,
std::vector<Vector<Number>> &values) const;
/**
template <typename Number>
void
get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<Tensor<1, spacedim, Number>> &gradients) const;
/**
template <typename Number>
void
get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<std::vector<Tensor<1, spacedim, Number>>> &gradients) const;
/**
template <typename Number>
void
get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Tensor<1, spacedim, Number>> & gradients) const;
+ std::vector<Tensor<1, spacedim, Number>> &gradients) const;
/**
* This function relates to the first of the get_function_gradients() function
template <typename Number>
void
get_function_gradients(
- const ReadVector<Number> & fe_function,
- const ArrayView<const types::global_dof_index> & indices,
+ const ReadVector<Number> &fe_function,
+ const ArrayView<const types::global_dof_index> &indices,
ArrayView<std::vector<Tensor<1, spacedim, Number>>> gradients,
const bool quadrature_points_fastest = false) const;
template <typename Number>
void
get_function_hessians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<Tensor<2, spacedim, Number>> &hessians) const;
/**
template <typename Number>
void
get_function_hessians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<std::vector<Tensor<2, spacedim, Number>>> &hessians,
const bool quadrature_points_fastest = false) const;
template <typename Number>
void
get_function_hessians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Tensor<2, spacedim, Number>> & hessians) const;
+ std::vector<Tensor<2, spacedim, Number>> &hessians) const;
/**
* This function relates to the first of the get_function_hessians() function
template <typename Number>
void
get_function_hessians(
- const ReadVector<Number> & fe_function,
- const ArrayView<const types::global_dof_index> & indices,
+ const ReadVector<Number> &fe_function,
+ const ArrayView<const types::global_dof_index> &indices,
ArrayView<std::vector<Tensor<2, spacedim, Number>>> hessians,
const bool quadrature_points_fastest = false) const;
template <typename Number>
void
get_function_laplacians(const ReadVector<Number> &fe_function,
- std::vector<Number> & laplacians) const;
+ std::vector<Number> &laplacians) const;
/**
* This function does the same as the other get_function_laplacians(), but
*/
template <typename Number>
void
- get_function_laplacians(const ReadVector<Number> & fe_function,
+ get_function_laplacians(const ReadVector<Number> &fe_function,
std::vector<Vector<Number>> &laplacians) const;
/**
template <typename Number>
void
get_function_laplacians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Number> & laplacians) const;
+ std::vector<Number> &laplacians) const;
/**
* This function relates to the first of the get_function_laplacians()
template <typename Number>
void
get_function_laplacians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Vector<Number>> & laplacians) const;
+ std::vector<Vector<Number>> &laplacians) const;
/**
* This function relates to the first of the get_function_laplacians()
template <typename Number>
void
get_function_laplacians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<std::vector<Number>> & laplacians,
+ std::vector<std::vector<Number>> &laplacians,
const bool quadrature_points_fastest = false) const;
/** @} */
template <typename Number>
void
get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<Tensor<3, spacedim, Number>> &third_derivatives) const;
/**
template <typename Number>
void
get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<std::vector<Tensor<3, spacedim, Number>>> &third_derivatives,
const bool quadrature_points_fastest = false) const;
template <typename Number>
void
get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Tensor<3, spacedim, Number>> & third_derivatives) const;
+ std::vector<Tensor<3, spacedim, Number>> &third_derivatives) const;
/**
* This function relates to the first of the get_function_third_derivatives()
template <typename Number>
void
get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
- const ArrayView<const types::global_dof_index> & indices,
+ const ReadVector<Number> &fe_function,
+ const ArrayView<const types::global_dof_index> &indices,
ArrayView<std::vector<Tensor<3, spacedim, Number>>> third_derivatives,
const bool quadrature_points_fastest = false) const;
/** @} */
template <typename Number>
void
get_interpolated_dof_values(const ReadVector<Number> &in,
- Vector<Number> & out) const;
+ Vector<Number> &out) const;
/**
* Call @p get_interpolated_dof_values of the iterator with the
* given arguments.
*/
void
- get_interpolated_dof_values(const IndexSet & in,
+ get_interpolated_dof_values(const IndexSet &in,
Vector<IndexSet::value_type> &out) const;
private:
bool initialized;
typename Triangulation<dim, spacedim>::cell_iterator cell;
- const DoFHandler<dim, spacedim> * dof_handler;
+ const DoFHandler<dim, spacedim> *dof_handler;
bool level_dof_access;
};
*/
template <typename Number>
void
- get_function_values(const ReadVector<Number> & fe_function,
+ get_function_values(const ReadVector<Number> &fe_function,
std::vector<solution_value_type<Number>> &values) const;
/**
template <typename Number>
void
get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_gradient_type<Number>> &gradients) const;
/**
template <typename Number>
void
get_function_hessians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_hessian_type<Number>> &hessians) const;
/**
template <typename Number>
void
get_function_laplacians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_laplacian_type<Number>> &laplacians) const;
/**
template <typename Number>
void
get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_third_derivative_type<Number>> &third_derivatives)
const;
*/
template <typename Number>
void
- get_function_values(const ReadVector<Number> & fe_function,
+ get_function_values(const ReadVector<Number> &fe_function,
std::vector<solution_value_type<Number>> &values) const;
/**
template <typename Number>
void
get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_gradient_type<Number>> &gradients) const;
/**
template <typename Number>
void
get_function_divergences(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_divergence_type<Number>> &divergences) const;
/**
*/
template <typename Number>
void
- get_function_curls(const ReadVector<Number> & fe_function,
+ get_function_curls(const ReadVector<Number> &fe_function,
std::vector<solution_curl_type<Number>> &curls) const;
/**
template <typename Number>
void
get_function_hessians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_hessian_type<Number>> &hessians) const;
/**
template <typename Number>
void
get_function_laplacians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_laplacian_type<Number>> &laplacians) const;
/**
template <typename Number>
void
get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_third_derivative_type<Number>> &third_derivatives)
const;
*/
template <typename Number>
void
- get_function_values(const ReadVector<Number> & fe_function,
+ get_function_values(const ReadVector<Number> &fe_function,
std::vector<solution_value_type<Number>> &values) const;
/**
template <typename Number>
void
get_function_divergences(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_divergence_type<Number>> &divergences) const;
/**
*/
template <typename Number>
void
- get_function_values(const ReadVector<Number> & fe_function,
+ get_function_values(const ReadVector<Number> &fe_function,
std::vector<solution_value_type<Number>> &values) const;
/**
template <typename Number>
void
get_function_divergences(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_divergence_type<Number>> &divergences) const;
/**
template <typename Number>
void
get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_gradient_type<Number>> &gradients) const;
/**
void
do_function_values(
const ArrayView<const Number> &dof_values,
- const Table<2, double> & shape_values,
+ const Table<2, double> &shape_values,
const std::vector<typename Scalar<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
std::vector<typename ProductType<Number, double>::type> &values);
template <int order, int dim, int spacedim, typename Number>
void
do_function_derivatives(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<order, spacedim>> &shape_derivatives,
const std::vector<typename Scalar<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_laplacians(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<2, spacedim>> &shape_hessians,
const std::vector<typename Scalar<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
void
do_function_values(
const ArrayView<const Number> &dof_values,
- const Table<2, double> & shape_values,
+ const Table<2, double> &shape_values,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
std::vector<
template <int order, int dim, int spacedim, typename Number>
void
do_function_derivatives(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<order, spacedim>> &shape_derivatives,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_symmetric_gradients(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_divergences(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_curls(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_laplacians(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<2, spacedim>> &shape_hessians,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_values(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const dealii::Table<2, double> &shape_values,
const std::vector<
typename SymmetricTensor<2, dim, spacedim>::ShapeFunctionData>
template <int dim, int spacedim, typename Number>
void
do_function_divergences(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<
typename SymmetricTensor<2, dim, spacedim>::ShapeFunctionData>
template <int dim, int spacedim, typename Number>
void
do_function_values(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const dealii::Table<2, double> &shape_values,
const std::vector<typename Tensor<2, dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_divergences(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<typename Tensor<2, dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_gradients(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<typename Tensor<2, dim, spacedim>::ShapeFunctionData>
&shape_function_data,
* Constructor.
*/
FE_WedgePoly(const unsigned int degree,
- const internal::GenericDoFsPerObject & dpos,
+ const internal::GenericDoFsPerObject &dpos,
const typename FiniteElementData<dim>::Conformity conformity);
/**
virtual void
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const override;
+ std::vector<double> &nodal_values) const override;
};
/**
virtual Point<spacedim>
transform_unit_to_real_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<dim> & p) const = 0;
+ const Point<dim> &p) const = 0;
/**
* Map the point @p p on the real @p cell to the corresponding point on the
virtual Point<dim>
transform_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<spacedim> & p) const = 0;
+ const Point<spacedim> &p) const = 0;
/**
* Map multiple points from the real point locations to points in reference
virtual void
transform_points_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const ArrayView<const Point<spacedim>> & real_points,
+ const ArrayView<const Point<spacedim>> &real_points,
const ArrayView<Point<dim>> &unit_points) const;
/**
project_real_point_to_unit_point_on_face(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const Point<spacedim> & p) const;
+ const Point<spacedim> &p) const;
/**
* @}
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const = 0;
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const;
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const;
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const = 0;
virtual void
fill_fe_immersed_surface_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const NonMatching::ImmersedSurfaceQuadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const NonMatching::ImmersedSurfaceQuadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const;
* const, but the tensors it points to are not.)
*/
virtual void
- transform(const ArrayView<const Tensor<1, dim>> & input,
+ transform(const ArrayView<const Tensor<1, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const = 0;
* const, but the tensors it points to are not.)
*/
virtual void
- transform(const ArrayView<const Tensor<2, dim>> & input,
+ transform(const ArrayView<const Tensor<2, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const = 0;
* transformed objects should be placed.
*/
virtual void
- transform(const ArrayView<const Tensor<3, dim>> & input,
+ transform(const ArrayView<const Tensor<3, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const = 0;
virtual void
add_line_support_points(
const typename Triangulation<dim>::cell_iterator &cell,
- std::vector<Point<dim>> & a) const override;
+ std::vector<Point<dim>> &a) const override;
/**
* For <tt>dim=3</tt>. Append the support points of all shape functions
virtual void
add_quad_support_points(
const typename Triangulation<dim>::cell_iterator &cell,
- std::vector<Point<dim>> & a) const override;
+ std::vector<Point<dim>> &a) const override;
};
/** @} */
void
MappingC1<2>::add_line_support_points(
const Triangulation<2>::cell_iterator &cell,
- std::vector<Point<2>> & a) const;
+ std::vector<Point<2>> &a) const;
template <>
void
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<1, dim>> & input,
+ transform(const ArrayView<const Tensor<1, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<2, dim>> & input,
+ transform(const ArrayView<const Tensor<2, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<3, dim>> & input,
+ transform(const ArrayView<const Tensor<3, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
void
fill_mapping_data_for_generic_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const ArrayView<const Point<dim>> & unit_points,
+ const ArrayView<const Point<dim>> &unit_points,
const UpdateFlags update_flags,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const;
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
virtual void
fill_fe_immersed_surface_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const NonMatching::ImmersedSurfaceQuadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const NonMatching::ImmersedSurfaceQuadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
update_cell_extents(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const InternalData & data) const;
+ const InternalData &data) const;
/**
* Compute the quadrature points if the UpdateFlags of the incoming
void
maybe_update_cell_quadrature_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const InternalData & data,
+ const InternalData &data,
std::vector<Point<dim>> &quadrature_points) const;
/**
maybe_update_face_quadrature_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const InternalData & data,
+ const InternalData &data,
std::vector<Point<dim>> &quadrature_points) const;
/**
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const InternalData & data,
+ const InternalData &data,
std::vector<Point<dim>> &quadrature_points) const;
/**
void
transform_quadrature_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const InternalData & data,
- const typename QProjector<dim>::DataSetDescriptor & offset,
+ const InternalData &data,
+ const typename QProjector<dim>::DataSetDescriptor &offset,
std::vector<Point<dim>> &quadrature_points) const;
/**
void
maybe_update_normal_vectors(
const unsigned int face_no,
- const InternalData & data,
+ const InternalData &data,
std::vector<Tensor<1, dim>> &normal_vectors) const;
/**
*/
void
maybe_update_jacobian_derivatives(
- const InternalData & data,
+ const InternalData &data,
const CellSimilarity::Similarity cell_similarity,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const;
*/
void
maybe_update_jacobians(
- const InternalData & data,
+ const InternalData &data,
const CellSimilarity::Similarity cell_similarity,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const;
*/
void
maybe_update_inverse_jacobians(
- const InternalData & data,
+ const InternalData &data,
const CellSimilarity::Similarity cell_similarity,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const;
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<1, dim>> & input,
+ transform(const ArrayView<const Tensor<1, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<2, dim>> & input,
+ transform(const ArrayView<const Tensor<2, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<3, dim>> & input,
+ transform(const ArrayView<const Tensor<3, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
* If an incompatible mask is passed, an exception is thrown.
*/
MappingFEField(const DoFHandler<dim, spacedim> &euler_dof_handler,
- const VectorType & euler_vector,
- const ComponentMask & mask = {});
+ const VectorType &euler_vector,
+ const ComponentMask &mask = {});
/**
* Constructor taking vectors on the multigrid levels rather than the active
* the other constructor need to be provided.
*/
MappingFEField(const DoFHandler<dim, spacedim> &euler_dof_handler,
- const std::vector<VectorType> & euler_vector,
- const ComponentMask & mask = {});
+ const std::vector<VectorType> &euler_vector,
+ const ComponentMask &mask = {});
/**
* Constructor with MGLevelObject instead of std::vector, otherwise the same
*/
MappingFEField(const DoFHandler<dim, spacedim> &euler_dof_handler,
const MGLevelObject<VectorType> &euler_vector,
- const ComponentMask & mask = {});
+ const ComponentMask &mask = {});
/**
* Copy constructor.
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<1, dim>> & input,
+ transform(const ArrayView<const Tensor<1, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<2, dim>> & input,
+ transform(const ArrayView<const Tensor<2, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<3, dim>> & input,
+ transform(const ArrayView<const Tensor<3, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
* Constructor.
*/
InternalData(const FiniteElement<dim, spacedim> &fe,
- const ComponentMask & mask);
+ const ComponentMask &mask);
/**
* Shape function at quadrature point. Shape functions are in tensor
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
virtual void
fill_fe_immersed_surface_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const NonMatching::ImmersedSurfaceQuadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const NonMatching::ImmersedSurfaceQuadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
Point<dim>
do_transform_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<spacedim> & p,
- const Point<dim> & initial_p_unit,
- InternalData & mdata) const;
+ const Point<spacedim> &p,
+ const Point<dim> &initial_p_unit,
+ InternalData &mdata) const;
/**
* Update internal degrees of freedom.
compute_data(const UpdateFlags update_flags,
const Quadrature<dim> &q,
const unsigned int n_original_q_points,
- InternalData & data) const;
+ InternalData &data) const;
void
compute_face_data(const UpdateFlags update_flags,
const Quadrature<dim> &q,
const unsigned int n_original_q_points,
- InternalData & data) const;
+ InternalData &data) const;
// Declare other MappingFEField classes friends.
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<1, dim>> & input,
+ transform(const ArrayView<const Tensor<1, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<2, dim>> & input,
+ transform(const ArrayView<const Tensor<2, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<3, dim>> & input,
+ transform(const ArrayView<const Tensor<3, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
virtual void
transform_points_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const ArrayView<const Point<spacedim>> & real_points,
+ const ArrayView<const Point<spacedim>> &real_points,
const ArrayView<Point<dim>> &unit_points) const override;
/**
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<1, dim>> & input,
+ transform(const ArrayView<const Tensor<1, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<2, dim>> & input,
+ transform(const ArrayView<const Tensor<2, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
- transform(const ArrayView<const Tensor<3, dim>> & input,
+ transform(const ArrayView<const Tensor<3, dim>> &input,
const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
void
fill_mapping_data_for_generic_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const ArrayView<const Point<dim>> & unit_points,
+ const ArrayView<const Point<dim>> &unit_points,
const UpdateFlags update_flags,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const;
fill_mapping_data_for_face_quadrature(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_number,
- const Quadrature<dim - 1> & face_quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &face_quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const;
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
virtual void
fill_fe_immersed_surface_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const NonMatching::ImmersedSurfaceQuadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const NonMatching::ImmersedSurfaceQuadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
Point<dim>
transform_real_to_unit_cell_internal(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const Point<dim> &initial_p_unit) const;
/**
virtual void
add_line_support_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- std::vector<Point<spacedim>> & a) const;
+ std::vector<Point<spacedim>> &a) const;
/**
* Append the support points of all shape functions located on bounding
virtual void
add_quad_support_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- std::vector<Point<spacedim>> & a) const;
+ std::vector<Point<spacedim>> &a) const;
// Make MappingQCache a friend since it needs to call the
// compute_mapping_support_points() function.
* to the location of cells of the underlying triangulation.
*/
MappingQ1Eulerian(const DoFHandler<dim, spacedim> &euler_dof_handler,
- const VectorType & euler_vector);
+ const VectorType &euler_vector);
/**
* Return the mapped vertices of the cell. For the current class, this
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
* Triangulation::Signals::any_change of the underlying triangulation.
*/
void
- initialize(const Mapping<dim, spacedim> & mapping,
+ initialize(const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &triangulation);
/**
* Triangulation::Signals::any_change of the underlying triangulation.
*/
void
- initialize(const Mapping<dim, spacedim> & mapping,
+ initialize(const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &tria,
const std::function<Point<spacedim>(
const typename Triangulation<dim, spacedim>::cell_iterator &,
- const Point<spacedim> &)> & transformation_function,
+ const Point<spacedim> &)> &transformation_function,
const bool function_describes_relative_displacement);
/**
* The same as above but taking a dealii::Function object.
*/
void
- initialize(const Mapping<dim, spacedim> & mapping,
+ initialize(const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &tria,
- const Function<spacedim> & transformation_function,
+ const Function<spacedim> &transformation_function,
const bool function_describes_relative_displacement);
/**
*/
template <typename VectorType>
void
- initialize(const Mapping<dim, spacedim> & mapping,
+ initialize(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const VectorType & vector,
+ const VectorType &vector,
const bool vector_describes_relative_displacement);
/**
*/
template <typename VectorType>
void
- initialize(const Mapping<dim, spacedim> & mapping,
+ initialize(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
const MGLevelObject<VectorType> &vectors,
const bool vector_describes_relative_displacement);
*/
MappingQEulerian(const unsigned int degree,
const DoFHandler<dim, spacedim> &euler_dof_handler,
- const VectorType & euler_vector,
+ const VectorType &euler_vector,
const unsigned int level = numbers::invalid_unsigned_int);
/**
fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const override;
inline Point<1>
transform_real_to_unit_cell(
const std::array<Point<spacedim>, GeometryInfo<1>::vertices_per_cell>
- & vertices,
+ &vertices,
const Point<spacedim> &p)
{
Assert(spacedim == 1, ExcInternalError());
inline Point<2>
transform_real_to_unit_cell(
const std::array<Point<spacedim>, GeometryInfo<2>::vertices_per_cell>
- & vertices,
+ &vertices,
const Point<spacedim> &p)
{
Assert(spacedim == 2, ExcInternalError());
*/
template <int dim>
std::vector<Point<dim>>
- unit_support_points(const std::vector<Point<1>> & line_support_points,
+ unit_support_points(const std::vector<Point<1>> &line_support_points,
const std::vector<unsigned int> &renumbering)
{
AssertDimension(Utilities::pow(line_support_points.size(), dim),
for (unsigned int j = 0; j < M; ++j)
for (unsigned int k = 0; k < M; ++k)
{
- const Point<3> & p = gl.point((i + 1) * (M + 2) * (M + 2) +
+ const Point<3> &p = gl.point((i + 1) * (M + 2) * (M + 2) +
(j + 1) * (M + 2) + (k + 1));
const unsigned int index_table = i * M * M + j * M + k;
template <int dim, int spacedim, typename Number>
inline Point<dim, Number>
do_transform_real_to_unit_cell_internal(
- const Point<spacedim, Number> & p,
- const Point<dim, Number> & initial_p_unit,
- const std::vector<Point<spacedim>> & points,
+ const Point<spacedim, Number> &p,
+ const Point<dim, Number> &initial_p_unit,
+ const std::vector<Point<spacedim>> &points,
const std::vector<Polynomials::Polynomial<double>> &polynomials_1d,
- const std::vector<unsigned int> & renumber,
+ const std::vector<unsigned int> &renumber,
const bool print_iterations_to_deallog = false)
{
if (print_iterations_to_deallog)
template <int dim>
inline Point<dim>
do_transform_real_to_unit_cell_internal_codim1(
- const Point<dim + 1> & p,
- const Point<dim> & initial_p_unit,
- const std::vector<Point<dim + 1>> & points,
+ const Point<dim + 1> &p,
+ const Point<dim> &initial_p_unit,
+ const std::vector<Point<dim + 1>> &points,
const std::vector<Polynomials::Polynomial<double>> &polynomials_1d,
- const std::vector<unsigned int> & renumber)
+ const std::vector<unsigned int> &renumber)
{
const unsigned int spacedim = dim + 1;
*/
InverseQuadraticApproximation(
const std::vector<Point<spacedim>> &real_support_points,
- const std::vector<Point<dim>> & unit_support_points)
+ const std::vector<Point<dim>> &unit_support_points)
: normalization_shift(real_support_points[0])
, normalization_length(
1. / real_support_points[0].distance(real_support_points[1]))
maybe_update_q_points_Jacobians_and_grads_tensor(
const CellSimilarity::Similarity cell_similarity,
const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
- std::vector<Point<spacedim>> & quadrature_points,
+ std::vector<Point<spacedim>> &quadrature_points,
std::vector<DerivativeForm<1, dim, spacedim>> &jacobians,
std::vector<DerivativeForm<1, spacedim, dim>> &inverse_jacobians,
std::vector<DerivativeForm<2, dim, spacedim>> &jacobian_grads)
const unsigned int n_points,
const unsigned int cur_index,
const DerivativeForm<1, dim, spacedim, VectorizedArray<double>>
- & derivative,
+ &derivative,
std::vector<DerivativeForm<1, dim, spacedim>> &result_array)
{
AssertDimension(result_array.size(), n_points);
for (unsigned int j = 0; j < n_lanes; ++j)
indices[j] = j * dim * spacedim;
const unsigned int even = (dim * spacedim) / 4 * 4;
- double * result_ptr = &result_array[cur_index][0][0];
+ double *result_ptr = &result_array[cur_index][0][0];
const VectorizedArray<double> *derivative_ptr = &derivative[0][0];
vectorized_transpose_and_store(
false, even, derivative_ptr, indices.data(), result_ptr);
maybe_update_q_points_Jacobians_generic(
const CellSimilarity::Similarity cell_similarity,
const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
- const ArrayView<const Point<dim>> & unit_points,
+ const ArrayView<const Point<dim>> &unit_points,
const std::vector<Polynomials::Polynomial<double>> &polynomials_1d,
const std::vector<unsigned int> &renumber_lexicographic_to_hierarchic,
- std::vector<Point<spacedim>> & quadrature_points,
+ std::vector<Point<spacedim>> &quadrature_points,
std::vector<DerivativeForm<1, dim, spacedim>> &jacobians,
std::vector<DerivativeForm<1, spacedim, dim>> &inverse_jacobians)
{
maybe_update_jacobian_grads(
const CellSimilarity::Similarity cell_similarity,
const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
- const ArrayView<const Point<dim>> & unit_points,
+ const ArrayView<const Point<dim>> &unit_points,
const std::vector<Polynomials::Polynomial<double>> &polynomials_1d,
const std::vector<unsigned int> &renumber_lexicographic_to_hierarchic,
std::vector<DerivativeForm<2, dim, spacedim>> &jacobian_grads)
maybe_update_jacobian_pushed_forward_grads(
const CellSimilarity::Similarity cell_similarity,
const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
- const ArrayView<const Point<dim>> & unit_points,
+ const ArrayView<const Point<dim>> &unit_points,
const std::vector<Polynomials::Polynomial<double>> &polynomials_1d,
- const std::vector<unsigned int> & renumber_lexicographic_to_hierarchic,
+ const std::vector<unsigned int> &renumber_lexicographic_to_hierarchic,
std::vector<Tensor<3, spacedim>> &jacobian_pushed_forward_grads)
{
if (data.update_each & update_jacobian_pushed_forward_grads)
maybe_update_jacobian_2nd_derivatives(
const CellSimilarity::Similarity cell_similarity,
const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
- const ArrayView<const Point<dim>> & unit_points,
+ const ArrayView<const Point<dim>> &unit_points,
const std::vector<Polynomials::Polynomial<double>> &polynomials_1d,
const std::vector<unsigned int> &renumber_lexicographic_to_hierarchic,
std::vector<DerivativeForm<3, dim, spacedim>> &jacobian_2nd_derivatives)
maybe_update_jacobian_pushed_forward_2nd_derivatives(
const CellSimilarity::Similarity cell_similarity,
const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
- const ArrayView<const Point<dim>> & unit_points,
+ const ArrayView<const Point<dim>> &unit_points,
const std::vector<Polynomials::Polynomial<double>> &polynomials_1d,
- const std::vector<unsigned int> & renumber_lexicographic_to_hierarchic,
+ const std::vector<unsigned int> &renumber_lexicographic_to_hierarchic,
std::vector<Tensor<4, spacedim>> &jacobian_pushed_forward_2nd_derivatives)
{
if (data.update_each & update_jacobian_pushed_forward_2nd_derivatives)
maybe_update_jacobian_3rd_derivatives(
const CellSimilarity::Similarity cell_similarity,
const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
- const ArrayView<const Point<dim>> & unit_points,
+ const ArrayView<const Point<dim>> &unit_points,
const std::vector<Polynomials::Polynomial<double>> &polynomials_1d,
const std::vector<unsigned int> &renumber_lexicographic_to_hierarchic,
std::vector<DerivativeForm<4, dim, spacedim>> &jacobian_3rd_derivatives)
maybe_update_jacobian_pushed_forward_3rd_derivatives(
const CellSimilarity::Similarity cell_similarity,
const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
- const ArrayView<const Point<dim>> & unit_points,
+ const ArrayView<const Point<dim>> &unit_points,
const std::vector<Polynomials::Polynomial<double>> &polynomials_1d,
- const std::vector<unsigned int> & renumber_lexicographic_to_hierarchic,
+ const std::vector<unsigned int> &renumber_lexicographic_to_hierarchic,
std::vector<Tensor<5, spacedim>> &jacobian_pushed_forward_3rd_derivatives)
{
if (data.update_each & update_jacobian_pushed_forward_3rd_derivatives)
const unsigned int face_no,
const unsigned int subface_no,
const unsigned int n_q_points,
- const std::vector<double> & weights,
+ const std::vector<double> &weights,
const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data)
const unsigned int face_no,
const unsigned int subface_no,
const typename QProjector<dim>::DataSetDescriptor data_set,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
const std::vector<Polynomials::Polynomial<double>> &polynomials_1d,
const std::vector<unsigned int> &renumber_lexicographic_to_hierarchic,
template <int dim, int spacedim, int rank>
inline void
transform_fields(
- const ArrayView<const Tensor<rank, dim>> & input,
+ const ArrayView<const Tensor<rank, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<rank, spacedim>> & output)
+ const ArrayView<Tensor<rank, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert((dynamic_cast<
template <int dim, int spacedim, int rank>
inline void
transform_gradients(
- const ArrayView<const Tensor<rank, dim>> & input,
+ const ArrayView<const Tensor<rank, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<rank, spacedim>> & output)
+ const ArrayView<Tensor<rank, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert((dynamic_cast<
template <int dim, int spacedim>
inline void
transform_hessians(
- const ArrayView<const Tensor<3, dim>> & input,
+ const ArrayView<const Tensor<3, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output)
+ const ArrayView<Tensor<3, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert((dynamic_cast<
transform_differential_forms(
const ArrayView<const DerivativeForm<rank, dim, spacedim>> &input,
const MappingKind mapping_kind,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_data,
- const ArrayView<Tensor<rank + 1, spacedim>> & output)
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
+ const ArrayView<Tensor<rank + 1, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert((dynamic_cast<
template <int spacedim>
void
create_triangulation_from_boundary_curve(
- const TopoDS_Edge & boundary,
+ const TopoDS_Edge &boundary,
Triangulation<2, spacedim> &tria,
const AdditionalParameters &prm = AdditionalParameters());
# endif
*/
CellId(const types::coarse_cell_id coarse_cell_id,
const unsigned int n_child_indices,
- const std::uint8_t * child_indices);
+ const std::uint8_t *child_indices);
/**
* Construct a CellId object with a given binary representation that was
*/
template <typename Accessor>
types::global_cell_index
- translate(const TriaIterator<Accessor> & cell,
+ translate(const TriaIterator<Accessor> &cell,
const types::global_cell_index i) const;
/**
template <int dim>
template <typename Accessor>
types::global_cell_index
- CellIDTranslator<dim>::translate(const TriaIterator<Accessor> & cell,
+ CellIDTranslator<dim>::translate(const TriaIterator<Accessor> &cell,
const types::global_cell_index i) const
{
static_assert(dim == Accessor::dimension &&
build_face_entities_templated(
const unsigned int face_dimensionality,
const std::vector<std::shared_ptr<CellTypeBase>> &cell_types,
- const std::vector<ReferenceCell> & cell_types_index,
- const CRS<unsigned int> & crs,
- CRS<unsigned int> & crs_d, // result
- CRS<unsigned int> & crs_0, // result
- TriaObjectsOrientations & orientations, // result
- const FU & second_key_function)
+ const std::vector<ReferenceCell> &cell_types_index,
+ const CRS<unsigned int> &crs,
+ CRS<unsigned int> &crs_d, // result
+ CRS<unsigned int> &crs_0, // result
+ TriaObjectsOrientations &orientations, // result
+ const FU &second_key_function)
{
const bool compatibility_mode = true;
- const std::vector<std::size_t> & cell_ptr = crs.ptr;
+ const std::vector<std::size_t> &cell_ptr = crs.ptr;
const std::vector<unsigned int> &cell_vertices = crs.col;
- std::vector<std::size_t> & ptr_d = crs_d.ptr;
- std::vector<unsigned int> & col_d = crs_d.col;
+ std::vector<std::size_t> &ptr_d = crs_d.ptr;
+ std::vector<unsigned int> &col_d = crs_d.col;
// note: we do not pre-allocate memory for these arrays because it turned
// out that counting unique entities is more expensive than push_back().
- std::vector<std::size_t> & ptr_0 = crs_0.ptr;
+ std::vector<std::size_t> &ptr_0 = crs_0.ptr;
std::vector<unsigned int> &col_0 = crs_0.col;
// clear
build_face_entities(
const unsigned int face_dimensionality,
const std::vector<std::shared_ptr<CellTypeBase>> &cell_types,
- const std::vector<ReferenceCell> & cell_types_index,
- const CRS<unsigned int> & crs,
- CRS<unsigned int> & crs_d,
- CRS<unsigned int> & crs_0,
- TriaObjectsOrientations & orientations,
- const FU & second_key_function)
+ const std::vector<ReferenceCell> &cell_types_index,
+ const CRS<unsigned int> &crs,
+ CRS<unsigned int> &crs_d,
+ CRS<unsigned int> &crs_0,
+ TriaObjectsOrientations &orientations,
+ const FU &second_key_function)
{
std::size_t max_n_vertices = 0;
inline void
build_intersection(
const std::vector<std::shared_ptr<CellTypeBase>> &cell_types,
- const std::vector<ReferenceCell> & cell_types_index,
- const CRS<unsigned int> & con_cv,
- const CRS<unsigned int> & con_cl,
- const CRS<unsigned int> & con_lv,
- const CRS<unsigned int> & con_cq,
- const CRS<unsigned int> & con_qv,
- const TriaObjectsOrientations & ori_cq,
- CRS<unsigned int> & con_ql, // result
- TriaObjectsOrientations & ori_ql, // result
- std::vector<ReferenceCell> & quad_t_id // result
+ const std::vector<ReferenceCell> &cell_types_index,
+ const CRS<unsigned int> &con_cv,
+ const CRS<unsigned int> &con_cl,
+ const CRS<unsigned int> &con_lv,
+ const CRS<unsigned int> &con_cq,
+ const CRS<unsigned int> &con_qv,
+ const TriaObjectsOrientations &ori_cq,
+ CRS<unsigned int> &con_ql, // result
+ TriaObjectsOrientations &ori_ql, // result
+ std::vector<ReferenceCell> &quad_t_id // result
)
{
// reset output
build_connectivity(const unsigned int dim,
const std::vector<std::shared_ptr<CellTypeBase>> &cell_t,
const std::vector<ReferenceCell> &cell_t_id,
- const CRS<T> & con_cv)
+ const CRS<T> &con_cv)
{
Connectivity<T> connectivity(dim, cell_t_id);
template <typename BaseIterator, typename Predicate>
DEAL_II_CXX20_REQUIRES((std::predicate<Predicate, BaseIterator>))
FilteredIterator<BaseIterator> make_filtered_iterator(const BaseIterator &i,
- const Predicate & p)
+ const Predicate &p)
{
FilteredIterator<BaseIterator> fi(p);
fi.set_to_next_positive(i);
DEAL_II_CXX20_REQUIRES((std::predicate<Predicate, BaseIterator>))
inline IteratorRange<FilteredIterator<BaseIterator>> filter_iterators(
IteratorRange<BaseIterator> i,
- const Predicate & p)
+ const Predicate &p)
{
FilteredIterator<BaseIterator> fi(p, *(i.begin()));
FilteredIterator<BaseIterator> fi_end(p, *(i.end()));
typename internal::FilteredIteratorImplementation::
NestFilteredIterators<BaseIterator, std::tuple<Predicate, Targs...>>::
type> filter_iterators(IteratorRange<BaseIterator> i,
- const Predicate & p,
+ const Predicate &p,
const Targs... args)
{
// Recursively create filtered iterators, one predicate at a time
// BaseIterator but try to go through constructing a new Accessor from fi
// which fails. Hence, we just use an explicit upcast and call the above-
// mentioned method.
- const BaseIterator &bi = fi;
- return operator=(bi);
+ const BaseIterator &bi = fi;
+ return operator=(bi);
}
*/
template <int dim>
void
- simplex(Triangulation<dim, dim> & tria,
+ simplex(Triangulation<dim, dim> &tria,
const std::vector<Point<dim>> &vertices);
/**
template <int dim, int spacedim>
void
reference_cell(Triangulation<dim, spacedim> &tria,
- const ReferenceCell & reference_cell);
+ const ReferenceCell &reference_cell);
/**
template <int dim, int spacedim>
void
hyper_rectangle(Triangulation<dim, spacedim> &tria,
- const Point<dim> & p1,
- const Point<dim> & p2,
+ const Point<dim> &p1,
+ const Point<dim> &p2,
const bool colorize = false);
/**
*/
template <int dim, int spacedim>
void
- subdivided_hyper_rectangle(Triangulation<dim, spacedim> & tria,
+ subdivided_hyper_rectangle(Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &repetitions,
- const Point<dim> & p1,
- const Point<dim> & p2,
+ const Point<dim> &p1,
+ const Point<dim> &p2,
const bool colorize = false);
/**
*/
template <int dim>
void
- subdivided_hyper_rectangle(Triangulation<dim> & tria,
+ subdivided_hyper_rectangle(Triangulation<dim> &tria,
const std::vector<std::vector<double>> &step_sizes,
- const Point<dim> & p_1,
- const Point<dim> & p_2,
+ const Point<dim> &p_1,
+ const Point<dim> &p_2,
const bool colorize = false);
/**
*/
template <int dim>
void
- subdivided_hyper_rectangle(Triangulation<dim> & tria,
+ subdivided_hyper_rectangle(Triangulation<dim> &tria,
const std::vector<std::vector<double>> &spacing,
- const Point<dim> & p,
+ const Point<dim> &p,
const Table<dim, types::material_id> &material_id,
const bool colorize = false);
*/
template <int dim, int spacedim>
void
- cheese(Triangulation<dim, spacedim> & tria,
+ cheese(Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &holes);
/**
*/
template <int dim>
void
- plate_with_a_hole(Triangulation<dim> & tria,
+ plate_with_a_hole(Triangulation<dim> &tria,
const double inner_radius = 0.4,
const double outer_radius = 1.,
const double pad_bottom = 2.,
const double pad_top = 2.,
const double pad_left = 1.,
const double pad_right = 1.,
- const Point<dim> & center = Point<dim>(),
+ const Point<dim> ¢er = Point<dim>(),
const types::manifold_id polar_manifold_id = 0,
const types::manifold_id tfi_manifold_id = 1,
const double L = 1.,
*/
template <int dim, int spacedim>
void
- general_cell(Triangulation<dim, spacedim> & tria,
+ general_cell(Triangulation<dim, spacedim> &tria,
const std::vector<Point<spacedim>> &vertices,
const bool colorize = false);
*/
template <int dim, int spacedim>
void
- subdivided_parallelepiped(Triangulation<dim, spacedim> & tria,
- const Point<spacedim> & origin,
+ subdivided_parallelepiped(Triangulation<dim, spacedim> &tria,
+ const Point<spacedim> &origin,
const std::array<Tensor<1, spacedim>, dim> &edges,
const std::vector<unsigned int> &subdivisions = {},
const bool colorize = false);
template <int dim>
void
hyper_ball(Triangulation<dim> &tria,
- const Point<dim> & center = Point<dim>(),
+ const Point<dim> ¢er = Point<dim>(),
const double radius = 1.,
const bool attach_spherical_manifold_on_boundary_cells = false);
template <int dim>
void
hyper_ball_balanced(Triangulation<dim> &tria,
- const Point<dim> & center = Point<dim>(),
+ const Point<dim> ¢er = Point<dim>(),
const double radius = 1.);
/**
* $\pi/2$.
*/
void
- non_standard_orientation_mesh(Triangulation<2> & tria,
+ non_standard_orientation_mesh(Triangulation<2> &tria,
const unsigned int n_rotate_middle_square);
/**
template <int dim>
void
quarter_hyper_ball(Triangulation<dim> &tria,
- const Point<dim> & center = Point<dim>(),
+ const Point<dim> ¢er = Point<dim>(),
const double radius = 1.);
/**
template <int dim>
void
half_hyper_ball(Triangulation<dim> &tria,
- const Point<dim> & center = Point<dim>(),
+ const Point<dim> ¢er = Point<dim>(),
const double radius = 1.);
/**
*/
template <int dim, int spacedim>
void
- pipe_junction(Triangulation<dim, spacedim> & tria,
+ pipe_junction(Triangulation<dim, spacedim> &tria,
const std::vector<std::pair<Point<spacedim>, double>> &openings,
const std::pair<Point<spacedim>, double> &bifurcation,
const double aspect_ratio = 0.5);
*/
template <int dim, int spacedim>
void
- hyper_cross(Triangulation<dim, spacedim> & tria,
+ hyper_cross(Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &sizes,
const bool colorize_cells = false);
*/
template <int dim, int spacedim>
void
- subdivided_hyper_L(Triangulation<dim, spacedim> & tria,
+ subdivided_hyper_L(Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &repetitions,
- const Point<dim> & bottom_left,
- const Point<dim> & top_right,
- const std::vector<int> & n_cells_to_remove);
+ const Point<dim> &bottom_left,
+ const Point<dim> &top_right,
+ const std::vector<int> &n_cells_to_remove);
/**
* Initialize the given Triangulation with a hypercube with a slit. In each
template <int dim>
void
hyper_shell(Triangulation<dim> &tria,
- const Point<dim> & center,
+ const Point<dim> ¢er,
const double inner_radius,
const double outer_radius,
const unsigned int n_cells = 0,
template <int dim>
void
eccentric_hyper_shell(Triangulation<dim> &triangulation,
- const Point<dim> & inner_center,
- const Point<dim> & outer_center,
+ const Point<dim> &inner_center,
+ const Point<dim> &outer_center,
const double inner_radius,
const double outer_radius,
const unsigned int n_cells);
template <int dim>
void
half_hyper_shell(Triangulation<dim> &tria,
- const Point<dim> & center,
+ const Point<dim> ¢er,
const double inner_radius,
const double outer_radius,
const unsigned int n_cells = 0,
template <int dim>
void
quarter_hyper_shell(Triangulation<dim> &tria,
- const Point<dim> & center,
+ const Point<dim> ¢er,
const double inner_radius,
const double outer_radius,
const unsigned int n_cells = 0,
template <int dim>
void
concentric_hyper_shells(Triangulation<dim> &triangulation,
- const Point<dim> & center,
+ const Point<dim> ¢er,
const double inner_radius = 0.125,
const double outer_radius = 0.25,
const unsigned int n_shells = 1,
void
generate_from_name_and_arguments(
Triangulation<dim, spacedim> &tria,
- const std::string & grid_generator_function_name,
- const std::string & grid_generator_function_arguments);
+ const std::string &grid_generator_function_name,
+ const std::string &grid_generator_function_arguments);
/**
* Generate a Triangulation from the zero level set of an implicit function,
*/
template <int dim>
void
- implicit_function(Triangulation<dim, 3> & tria,
- const Function<3> & implicit_function,
+ implicit_function(Triangulation<dim, 3> &tria,
+ const Function<3> &implicit_function,
const CGALWrappers::AdditionalData<dim> &data =
CGALWrappers::AdditionalData<dim>{},
const Point<3> &interior_point = Point<3>(),
- const double & outer_ball_radius = 1.0);
+ const double &outer_ball_radius = 1.0);
/**
* Create a deal.II Triangulation<3> out of a deal.II Triangulation<2,3>
*/
void
surface_mesh_to_volumetric_mesh(const Triangulation<2, 3> &surface_tria,
- Triangulation<3> & vol_tria,
+ Triangulation<3> &vol_tria,
const CGALWrappers::AdditionalData<3> &data =
CGALWrappers::AdditionalData<3>{});
/** @} */
void
merge_triangulations(const Triangulation<dim, spacedim> &triangulation_1,
const Triangulation<dim, spacedim> &triangulation_2,
- Triangulation<dim, spacedim> & result,
+ Triangulation<dim, spacedim> &result,
const double duplicated_vertex_tolerance = 1.0e-12,
const bool copy_manifold_ids = false,
const bool copy_boundary_ids = false);
void
merge_triangulations(
const std::vector<const Triangulation<dim, spacedim> *> &triangulations,
- Triangulation<dim, spacedim> & result,
+ Triangulation<dim, spacedim> &result,
const double duplicated_vertex_tolerance = 1.0e-12,
const bool copy_manifold_ids = false,
const bool copy_boundary_ids = false);
template <int dim, int spacedim = dim>
void
replicate_triangulation(const Triangulation<dim, spacedim> &input,
- const std::vector<unsigned int> & extents,
- Triangulation<dim, spacedim> & result);
+ const std::vector<unsigned int> &extents,
+ Triangulation<dim, spacedim> &result);
/**
* Given the two triangulations specified as the first two arguments, create
create_union_triangulation(
const Triangulation<dim, spacedim> &triangulation_1,
const Triangulation<dim, spacedim> &triangulation_2,
- Triangulation<dim, spacedim> & result);
+ Triangulation<dim, spacedim> &result);
/**
* This function creates a triangulation that consists of the same cells as
create_triangulation_with_removed_cells(
const Triangulation<dim, spacedim> &input_triangulation,
const std::set<typename Triangulation<dim, spacedim>::active_cell_iterator>
- & cells_to_remove,
+ &cells_to_remove,
Triangulation<dim, spacedim> &result);
/**
*/
void
extrude_triangulation(
- const Triangulation<2, 2> & input,
+ const Triangulation<2, 2> &input,
const unsigned int n_slices,
const double height,
- Triangulation<3, 3> & result,
+ Triangulation<3, 3> &result,
const bool copy_manifold_ids = false,
const std::vector<types::manifold_id> &manifold_priorities = {});
*/
void
extrude_triangulation(
- const Triangulation<2, 2> & input,
+ const Triangulation<2, 2> &input,
const unsigned int n_slices,
const double height,
- Triangulation<2, 2> & result,
+ Triangulation<2, 2> &result,
const bool copy_manifold_ids = false,
const std::vector<types::manifold_id> &manifold_priorities = {});
*/
void
extrude_triangulation(
- const Triangulation<2, 2> & input,
- const std::vector<double> & slice_coordinates,
- Triangulation<3, 3> & result,
+ const Triangulation<2, 2> &input,
+ const std::vector<double> &slice_coordinates,
+ Triangulation<3, 3> &result,
const bool copy_manifold_ids = false,
const std::vector<types::manifold_id> &manifold_priorities = {});
*/
void
extrude_triangulation(
- const Triangulation<2, 2> & input,
- const std::vector<double> & slice_coordinates,
- Triangulation<2, 2> & result,
+ const Triangulation<2, 2> &input,
+ const std::vector<double> &slice_coordinates,
+ Triangulation<2, 2> &result,
const bool copy_manifold_ids = false,
const std::vector<types::manifold_id> &manifold_priorities = {});
template <int dim, int spacedim1, int spacedim2>
void
flatten_triangulation(const Triangulation<dim, spacedim1> &in_tria,
- Triangulation<dim, spacedim2> & out_tria);
+ Triangulation<dim, spacedim2> &out_tria);
/**
* Convert a triangulation consisting only of hypercube cells
template <int spacedim>
void
convert_hypercube_to_simplex_mesh(const Triangulation<1, spacedim> &in_tria,
- Triangulation<1, spacedim> & out_tria);
+ Triangulation<1, spacedim> &out_tria);
#endif
/**
void
create_triangulation(
Triangulation<dim, dim> &tria,
- const AdditionalData & additional_data = AdditionalData());
+ const AdditionalData &additional_data = AdditionalData());
template <int dim>
void
create_triangulation(
- Triangulation<dim, dim> & tria,
+ Triangulation<dim, dim> &tria,
std::vector<GridTools::PeriodicFacePair<
typename Triangulation<dim, dim>::cell_iterator>> &periodic_faces,
const AdditionalData &additional_data = AdditionalData());
template <int dim, int spacedim>
void
subdivided_hyper_rectangle_with_simplices(
- Triangulation<dim, spacedim> & tria,
+ Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &repetitions,
- const Point<dim> & p1,
- const Point<dim> & p2,
+ const Point<dim> &p1,
+ const Point<dim> &p2,
const bool colorize = false);
/**
typename ExtractBoundaryMesh<MeshType, dim, spacedim>::return_type
# endif
#endif
- extract_boundary_mesh(const MeshType<dim, spacedim> & volume_mesh,
- MeshType<dim - 1, spacedim> & surface_mesh,
+ extract_boundary_mesh(const MeshType<dim, spacedim> &volume_mesh,
+ MeshType<dim - 1, spacedim> &surface_mesh,
const std::set<types::boundary_id> &boundary_ids =
std::set<types::boundary_id>());
* further ado by the user.
*/
static void
- debug_output_grid(const std::vector<CellData<dim>> & cells,
+ debug_output_grid(const std::vector<CellData<dim>> &cells,
const std::vector<Point<spacedim>> &vertices,
- std::ostream & out);
+ std::ostream &out);
private:
/**
* function execution..
*/
static void
- parse_tecplot_header(std::string & header,
+ parse_tecplot_header(std::string &header,
std::vector<unsigned int> &tecplot2deal,
- unsigned int & n_vars,
- unsigned int & n_vertices,
- unsigned int & n_cells,
+ unsigned int &n_vars,
+ unsigned int &n_vertices,
+ unsigned int &n_cells,
std::vector<unsigned int> &IJK,
- bool & structured,
- bool & blocked);
+ bool &structured,
+ bool &blocked);
/**
* Input format used by read() if no format is given.
template <>
void
GridIn<2>::debug_output_grid(const std::vector<CellData<2>> &cells,
- const std::vector<Point<2>> & vertices,
- std::ostream & out);
+ const std::vector<Point<2>> &vertices,
+ std::ostream &out);
template <>
void
GridIn<2, 3>::debug_output_grid(const std::vector<CellData<2>> &cells,
- const std::vector<Point<3>> & vertices,
- std::ostream & out);
+ const std::vector<Point<3>> &vertices,
+ std::ostream &out);
template <>
void
GridIn<3>::debug_output_grid(const std::vector<CellData<3>> &cells,
- const std::vector<Point<3>> & vertices,
- std::ostream & out);
+ const std::vector<Point<3>> &vertices,
+ std::ostream &out);
#endif // DOXYGEN
DEAL_II_NAMESPACE_CLOSE
template <int dim, int spacedim>
void
write_gnuplot(const Triangulation<dim, spacedim> &tria,
- std::ostream & out,
- const Mapping<dim, spacedim> * mapping = nullptr) const;
+ std::ostream &out,
+ const Mapping<dim, spacedim> *mapping = nullptr) const;
/**
* Write the triangulation in the msh format.
template <int dim, int spacedim>
void
write_msh(const Triangulation<dim, spacedim> &tria,
- const std::string & filename) const;
+ const std::string &filename) const;
#endif
/**
template <int dim, int spacedim>
void
write_eps(const Triangulation<dim, spacedim> &tria,
- std::ostream & out,
- const Mapping<dim, spacedim> * mapping = nullptr) const;
+ std::ostream &out,
+ const Mapping<dim, spacedim> *mapping = nullptr) const;
/**
* Write two-dimensional XFig-file.
template <int dim, int spacedim>
void
write_xfig(const Triangulation<dim, spacedim> &tria,
- std::ostream & out,
- const Mapping<dim, spacedim> * mapping = nullptr) const;
+ std::ostream &out,
+ const Mapping<dim, spacedim> *mapping = nullptr) const;
/**
* Write the triangulation in the SVG format.
template <int dim, int spacedim>
void
write_mathgl(const Triangulation<dim, spacedim> &tria,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Write triangulation in VTK format. This function writes a
template <int dim, int spacedim>
void
write(const Triangulation<dim, spacedim> &tria,
- std::ostream & out,
+ std::ostream &out,
const OutputFormat output_format,
- const Mapping<dim, spacedim> * mapping = nullptr) const;
+ const Mapping<dim, spacedim> *mapping = nullptr) const;
/**
* Write mesh in default format set by ParameterHandler.
template <int dim, int spacedim>
void
write(const Triangulation<dim, spacedim> &tria,
- std::ostream & out,
- const Mapping<dim, spacedim> * mapping = nullptr) const;
+ std::ostream &out,
+ const Mapping<dim, spacedim> *mapping = nullptr) const;
/**
* Set flags for DX output
unsigned int
write_msh_faces(const Triangulation<dim, spacedim> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 1d. Does nothing.
unsigned int
write_msh_faces(const Triangulation<1, 1> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 1d, 2sd. Does
* nothing.
unsigned int
write_msh_faces(const Triangulation<1, 2> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
unsigned int
write_msh_faces(const Triangulation<1, 3> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
unsigned int
write_msh_lines(const Triangulation<dim, spacedim> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 1d. Does nothing.
unsigned int
write_msh_lines(const Triangulation<1, 1> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 1d, 2sd. Does
unsigned int
write_msh_lines(const Triangulation<1, 2> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 1d, 3sd. Does
unsigned int
write_msh_lines(const Triangulation<1, 3> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 2d. Does nothing.
*/
unsigned int
write_msh_lines(const Triangulation<2, 2> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 2d, 3sd. Does
* nothing.
unsigned int
write_msh_lines(const Triangulation<2, 3> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Write the grid information about faces to @p out. Only those faces are
unsigned int
write_ucd_faces(const Triangulation<dim, spacedim> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 1d. Does nothing.
unsigned int
write_ucd_faces(const Triangulation<1, 1> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 1d, 2sd. Does
unsigned int
write_ucd_faces(const Triangulation<1, 2> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
unsigned int
write_ucd_faces(const Triangulation<1, 3> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
unsigned int
write_ucd_lines(const Triangulation<dim, spacedim> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 1d. Does nothing.
unsigned int
write_ucd_lines(const Triangulation<1, 1> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 1d, 2sd. Does
* nothing.
unsigned int
write_ucd_lines(const Triangulation<1, 2> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 1d, 3sd. Does
* nothing.
unsigned int
write_ucd_lines(const Triangulation<1, 3> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
unsigned int
write_ucd_lines(const Triangulation<2, 2> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Declaration of the specialization of above function for 2d, 3sd. Does
* nothing.
unsigned int
write_ucd_lines(const Triangulation<2, 3> &tria,
const unsigned int next_element_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
void
refine_and_coarsen_fixed_number(
Triangulation<dim, spacedim> &triangulation,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double top_fraction_of_cells,
const double bottom_fraction_of_cells,
const unsigned int max_n_cells = std::numeric_limits<unsigned int>::max());
void
refine_and_coarsen_fixed_fraction(
Triangulation<dim, spacedim> &tria,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double top_fraction,
const double bottom_fraction,
const unsigned int max_n_cells = std::numeric_limits<unsigned int>::max(),
template <int dim, typename Number, int spacedim>
void
refine_and_coarsen_optimize(Triangulation<dim, spacedim> &tria,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const unsigned int order = 2);
/**
template <int dim, typename Number, int spacedim>
void
refine(Triangulation<dim, spacedim> &tria,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double threshold,
const unsigned int max_to_mark = numbers::invalid_unsigned_int);
template <int dim, typename Number, int spacedim>
void
coarsen(Triangulation<dim, spacedim> &tria,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double threshold);
/**
template <int dim, int spacedim>
double
volume(const Triangulation<dim, spacedim> &tria,
- const Mapping<dim, spacedim> & mapping);
+ const Mapping<dim, spacedim> &mapping);
/**
* Return an approximation of the diameter of the smallest active cell of a
double
minimal_cell_diameter(
const Triangulation<dim, spacedim> &triangulation,
- const Mapping<dim, spacedim> & mapping =
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()
double
maximal_cell_diameter(
const Triangulation<dim, spacedim> &triangulation,
- const Mapping<dim, spacedim> & mapping =
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()
*/
template <int dim>
double
- cell_measure(const std::vector<Point<dim>> & all_vertices,
+ cell_measure(const std::vector<Point<dim>> &all_vertices,
const ArrayView<const unsigned int> &vertex_indices);
/**
*/
template <int dim>
Vector<double>
- compute_aspect_ratio_of_cells(const Mapping<dim> & mapping,
+ compute_aspect_ratio_of_cells(const Mapping<dim> &mapping,
const Triangulation<dim> &triangulation,
- const Quadrature<dim> & quadrature);
+ const Quadrature<dim> &quadrature);
/**
* Computes the maximum aspect ratio by taking the maximum over all cells.
*/
template <int dim>
double
- compute_maximum_aspect_ratio(const Mapping<dim> & mapping,
+ compute_maximum_aspect_ratio(const Mapping<dim> &mapping,
const Triangulation<dim> &triangulation,
- const Quadrature<dim> & quadrature);
+ const Quadrature<dim> &quadrature);
/**
* Compute the smallest box containing the entire triangulation.
template <typename Iterator>
Point<Iterator::AccessorType::space_dimension>
project_to_object(
- const Iterator & object,
+ const Iterator &object,
const Point<Iterator::AccessorType::space_dimension> &trial_point);
/**
template <int dim, int spacedim>
void
delete_unused_vertices(std::vector<Point<spacedim>> &vertices,
- std::vector<CellData<dim>> & cells,
- SubCellData & subcelldata);
+ std::vector<CellData<dim>> &cells,
+ SubCellData &subcelldata);
/**
* Remove vertices that are duplicated, due to the input of a structured
template <int dim, int spacedim>
void
delete_duplicated_vertices(std::vector<Point<spacedim>> &all_vertices,
- std::vector<CellData<dim>> & cells,
- SubCellData & subcelldata,
- std::vector<unsigned int> & considered_vertices,
+ std::vector<CellData<dim>> &cells,
+ SubCellData &subcelldata,
+ std::vector<unsigned int> &considered_vertices,
const double tol = 1e-12);
/**
void
invert_all_negative_measure_cells(
const std::vector<Point<spacedim>> &all_vertices,
- std::vector<CellData<dim>> & cells);
+ std::vector<CellData<dim>> &cells);
/**
* Check the given cells and inverts any cell that is considered to have
std::size_t
invert_cells_with_negative_measure(
const std::vector<Point<spacedim>> &all_vertices,
- std::vector<CellData<dim>> & cells);
+ std::vector<CellData<dim>> &cells);
/**
* Given a vector of CellData objects describing a mesh, reorder their
std::assignable_from<
Point<spacedim> &,
std::invoke_result_t<Transformation, Point<spacedim>>>))
- void transform(const Transformation & transformation,
+ void transform(const Transformation &transformation,
Triangulation<dim, spacedim> &triangulation);
/**
*/
template <int dim, int spacedim>
void
- shift(const Tensor<1, spacedim> & shift_vector,
+ shift(const Tensor<1, spacedim> &shift_vector,
Triangulation<dim, spacedim> &triangulation);
void
rotate(const Tensor<1, 3, double> &axis,
const double angle,
- Triangulation<dim, 3> & triangulation);
+ Triangulation<dim, 3> &triangulation);
/**
* Rotate all vertices of the given @p triangulation in counter-clockwise
template <int dim>
void
laplace_transform(const std::map<unsigned int, Point<dim>> &new_points,
- Triangulation<dim> & tria,
+ Triangulation<dim> &tria,
const Function<dim, double> *coefficient = nullptr,
const bool solve_for_absolute_positions = false);
return_type
#endif
compute_point_locations(
- const Cache<dim, spacedim> & cache,
+ const Cache<dim, spacedim> &cache,
const std::vector<Point<spacedim>> &points,
const typename Triangulation<dim, spacedim>::active_cell_iterator
&cell_hint =
return_type
#endif
compute_point_locations_try_all(
- const Cache<dim, spacedim> & cache,
+ const Cache<dim, spacedim> &cache,
const std::vector<Point<spacedim>> &points,
const typename Triangulation<dim, spacedim>::active_cell_iterator
&cell_hint =
return_type
#endif
distributed_compute_point_locations(
- const GridTools::Cache<dim, spacedim> & cache,
- const std::vector<Point<spacedim>> & local_points,
+ const GridTools::Cache<dim, spacedim> &cache,
+ const std::vector<Point<spacedim>> &local_points,
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bboxes,
const double tolerance = 1e-10,
- const std::vector<bool> & marked_vertices = {},
+ const std::vector<bool> &marked_vertices = {},
const bool enforce_unique_mapping = true);
namespace internal
template <int dim, int spacedim>
DistributedComputePointLocationsInternal<dim, spacedim>
distributed_compute_point_locations(
- const GridTools::Cache<dim, spacedim> & cache,
- const std::vector<Point<spacedim>> & points,
+ const GridTools::Cache<dim, spacedim> &cache,
+ const std::vector<Point<spacedim>> &points,
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bboxes,
- const std::vector<bool> & marked_vertices,
+ const std::vector<bool> &marked_vertices,
const double tolerance,
const bool perform_handshake,
const bool enforce_unique_mapping = false);
convert_to_distributed_compute_point_locations_internal(
const unsigned int n_points_1D,
const Triangulation<dim, spacedim> &tria,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const bool consistent_numbering_of_sender_and_receiver = false) const;
private:
std::map<unsigned int, std::vector<unsigned int>>
communicate_indices(
const std::vector<std::tuple<unsigned int, unsigned int, unsigned int>>
- & point_recv_components,
+ &point_recv_components,
const MPI_Comm comm) const;
};
template <int structdim, int dim, int spacedim>
DistributedComputeIntersectionLocationsInternal<structdim, spacedim>
distributed_compute_intersection_locations(
- const Cache<dim, spacedim> & cache,
+ const Cache<dim, spacedim> &cache,
const std::vector<std::vector<Point<spacedim>>> &intersection_requests,
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bboxes,
- const std::vector<bool> & marked_vertices,
+ const std::vector<bool> &marked_vertices,
const double tolerance);
} // namespace internal
std::map<unsigned int, Point<spacedim>>
extract_used_vertices(
const Triangulation<dim, spacedim> &container,
- const Mapping<dim, spacedim> & mapping =
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()
template <int spacedim>
unsigned int
find_closest_vertex(const std::map<unsigned int, Point<spacedim>> &vertices,
- const Point<spacedim> & p);
+ const Point<spacedim> &p);
/**
* Find and return the index of the used vertex (or marked vertex) in a
(concepts::is_triangulation_or_dof_handler<MeshType<dim, spacedim>>))
unsigned int find_closest_vertex(
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
- const std::vector<bool> & marked_vertices = {});
+ const Point<spacedim> &p,
+ const std::vector<bool> &marked_vertices = {});
/**
* Find and return the index of the used vertex (or marked vertex) in a
DEAL_II_CXX20_REQUIRES(
(concepts::is_triangulation_or_dof_handler<MeshType<dim, spacedim>>))
unsigned int find_closest_vertex(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
- const std::vector<bool> & marked_vertices = {});
+ const Point<spacedim> &p,
+ const std::vector<bool> &marked_vertices = {});
/**
MeshType::space_dimension,
MeshType>::type>
#endif
- find_cells_adjacent_to_vertex(const MeshType & container,
+ find_cells_adjacent_to_vertex(const MeshType &container,
const unsigned int vertex_index);
/**
ActiveCellIterator<dim, spacedim, MeshType<dim, spacedim>>::type,
Point<dim>>
#endif
- find_active_cell_around_point(const Mapping<dim, spacedim> & mapping,
+ find_active_cell_around_point(const Mapping<dim, spacedim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const std::vector<bool> &marked_vertices = {},
const double tolerance = 1.e-10);
ActiveCellIterator<dim, spacedim, MeshType<dim, spacedim>>::type
#endif
find_active_cell_around_point(const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const std::vector<bool> &marked_vertices = {},
const double tolerance = 1.e-10);
Point<dim>>
find_active_cell_around_point(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & mesh,
- const Point<spacedim> & p,
+ const DoFHandler<dim, spacedim> &mesh,
+ const Point<spacedim> &p,
const double tolerance = 1.e-10);
/**
Point<dim>>
find_active_cell_around_point(
const Cache<dim, spacedim> &cache,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const typename Triangulation<dim, spacedim>::active_cell_iterator &
cell_hint = typename Triangulation<dim, spacedim>::active_cell_iterator(),
const std::vector<bool> &marked_vertices = {},
Point<dim>>
#endif
find_active_cell_around_point(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const std::vector<
std::set<typename MeshType<dim, spacedim>::active_cell_iterator>>
&vertex_to_cell_map,
Point<dim>>>
#endif
find_all_active_cells_around_point(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const double tolerance,
const std::pair<typename MeshType<dim, spacedim>::active_cell_iterator,
- Point<dim>> & first_cell,
+ Point<dim>> &first_cell,
const std::vector<
std::set<typename MeshType<dim, spacedim>::active_cell_iterator>>
*vertex_to_cells = nullptr);
Point<dim>>>
#endif
find_all_active_cells_around_point(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const double tolerance = 1e-10,
- const std::vector<bool> & marked_vertices = {});
+ const std::vector<bool> &marked_vertices = {});
/**
* Return a list of all descendants of the given cell that are active. For
template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void get_active_neighbors(
- const typename MeshType::active_cell_iterator & cell,
+ const typename MeshType::active_cell_iterator &cell,
std::vector<typename MeshType::active_cell_iterator> &active_neighbors);
/**
vector<typename MeshType::cell_iterator> compute_cell_halo_layer_on_level(
const MeshType &mesh,
const std::function<bool(const typename MeshType::cell_iterator &)>
- & predicate,
+ &predicate,
const unsigned int level);
vector<typename MeshType::active_cell_iterator> compute_active_cell_layer_within_distance(
const MeshType &mesh,
const std::function<bool(const typename MeshType::active_cell_iterator &)>
- & predicate,
+ &predicate,
const double layer_thickness);
/**
vector<BoundingBox<MeshType::space_dimension>> compute_mesh_predicate_bounding_box(
const MeshType &mesh,
const std::function<bool(const typename MeshType::active_cell_iterator &)>
- & predicate,
+ &predicate,
const unsigned int refinement_level = 0,
const bool allow_merge = false,
const unsigned int max_boxes = numbers::invalid_unsigned_int);
#endif
guess_point_owner(
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bboxes,
- const std::vector<Point<spacedim>> & points);
+ const std::vector<Point<spacedim>> &points);
/**
#endif
guess_point_owner(
const RTree<std::pair<BoundingBox<spacedim>, unsigned int>> &covering_rtree,
- const std::vector<Point<spacedim>> & points);
+ const std::vector<Point<spacedim>> &points);
/**
unsigned int
find_closest_vertex_of_cell(
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
- const Point<spacedim> & position,
- const Mapping<dim, spacedim> & mapping =
+ const Point<spacedim> &position,
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()
void
get_face_connectivity_of_cells(
const Triangulation<dim, spacedim> &triangulation,
- DynamicSparsityPattern & connectivity);
+ DynamicSparsityPattern &connectivity);
/**
* Produce a sparsity pattern in which nonzero entries indicate that two
void
get_vertex_connectivity_of_cells(
const Triangulation<dim, spacedim> &triangulation,
- DynamicSparsityPattern & connectivity);
+ DynamicSparsityPattern &connectivity);
/**
* Produce a sparsity pattern for a given level mesh in which nonzero entries
get_vertex_connectivity_of_cells_on_level(
const Triangulation<dim, spacedim> &triangulation,
const unsigned int level,
- DynamicSparsityPattern & connectivity);
+ DynamicSparsityPattern &connectivity);
/**
* Use graph partitioner to partition the active cells making up the entire
template <int dim, int spacedim>
void
partition_triangulation(const unsigned int n_partitions,
- Triangulation<dim, spacedim> & triangulation,
+ Triangulation<dim, spacedim> &triangulation,
const SparsityTools::Partitioner partitioner =
SparsityTools::Partitioner::metis);
void
partition_triangulation(const unsigned int n_partitions,
const std::vector<unsigned int> &cell_weights,
- Triangulation<dim, spacedim> & triangulation,
+ Triangulation<dim, spacedim> &triangulation,
const SparsityTools::Partitioner partitioner =
SparsityTools::Partitioner::metis);
template <int dim, int spacedim>
void
partition_triangulation(const unsigned int n_partitions,
- const SparsityPattern & cell_connection_graph,
+ const SparsityPattern &cell_connection_graph,
Triangulation<dim, spacedim> &triangulation,
const SparsityTools::Partitioner partitioner =
SparsityTools::Partitioner::metis);
void
partition_triangulation(const unsigned int n_partitions,
const std::vector<unsigned int> &cell_weights,
- const SparsityPattern & cell_connection_graph,
+ const SparsityPattern &cell_connection_graph,
Triangulation<dim, spacedim> &triangulation,
const SparsityTools::Partitioner partitioner =
SparsityTools::Partitioner::metis);
template <int dim, int spacedim>
std::vector<types::subdomain_id>
get_subdomain_association(const Triangulation<dim, spacedim> &triangulation,
- const std::vector<CellId> & cell_ids);
+ const std::vector<CellId> &cell_ids);
/**
* For each active cell, return in the output array to which subdomain (as
template <int dim, int spacedim>
void
get_subdomain_association(const Triangulation<dim, spacedim> &triangulation,
- std::vector<types::subdomain_id> & subdomain);
+ std::vector<types::subdomain_id> &subdomain);
/**
* Count how many cells are uniquely associated with the given @p subdomain
typename Triangulation<dim, spacedim>::DistortedCellList
fix_up_distorted_child_cells(
const typename Triangulation<dim, spacedim>::DistortedCellList
- & distorted_cells,
+ &distorted_cells,
Triangulation<dim, spacedim> &triangulation);
template <typename FaceIterator>
bool
orthogonal_equality(
- std::bitset<3> & orientation,
- const FaceIterator & face1,
- const FaceIterator & face2,
+ std::bitset<3> &orientation,
+ const FaceIterator &face1,
+ const FaceIterator &face2,
const unsigned int direction,
const Tensor<1, FaceIterator::AccessorType::space_dimension> &offset =
Tensor<1, FaceIterator::AccessorType::space_dimension>(),
template <typename FaceIterator>
bool
orthogonal_equality(
- const FaceIterator & face1,
- const FaceIterator & face2,
+ const FaceIterator &face1,
+ const FaceIterator &face2,
const unsigned int direction,
const Tensor<1, FaceIterator::AccessorType::space_dimension> &offset =
Tensor<1, FaceIterator::AccessorType::space_dimension>(),
template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void collect_periodic_faces(
- const MeshType & mesh,
+ const MeshType &mesh,
const types::boundary_id b_id1,
const types::boundary_id b_id2,
const unsigned int direction,
std::vector<PeriodicFacePair<typename MeshType::cell_iterator>>
- & matched_pairs,
+ &matched_pairs,
const Tensor<1, MeshType::space_dimension> &offset =
dealii::Tensor<1, MeshType::space_dimension>(),
const FullMatrix<double> &matrix = FullMatrix<double>());
template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void collect_periodic_faces(
- const MeshType & mesh,
+ const MeshType &mesh,
const types::boundary_id b_id,
const unsigned int direction,
std::vector<PeriodicFacePair<typename MeshType::cell_iterator>>
- & matched_pairs,
+ &matched_pairs,
const dealii::Tensor<1, MeshType::space_dimension> &offset =
dealii::Tensor<1, MeshType::space_dimension>(),
const FullMatrix<double> &matrix = FullMatrix<double>());
map_boundary_to_manifold_ids(
const std::vector<types::boundary_id> &src_boundary_ids,
const std::vector<types::manifold_id> &dst_manifold_ids,
- Triangulation<dim, spacedim> & tria,
+ Triangulation<dim, spacedim> &tria,
const std::vector<types::boundary_id> &reset_boundary_ids = {});
/**
template <int dim, int spacedim>
void
assign_co_dimensional_manifold_indicators(
- Triangulation<dim, spacedim> & tria,
+ Triangulation<dim, spacedim> &tria,
const std::function<types::manifold_id(
const std::set<types::manifold_id> &)> &disambiguation_function =
[](const std::set<types::manifold_id> &manifold_ids) {
template <typename DataType, typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void exchange_cell_data_to_ghosts(
- const MeshType & mesh,
+ const MeshType &mesh,
const std::function<std::optional<DataType>(
const typename MeshType::active_cell_iterator &)> &pack,
const std::function<void(const typename MeshType::active_cell_iterator &,
- const DataType &)> & unpack,
+ const DataType &)> &unpack,
const std::function<bool(const typename MeshType::active_cell_iterator &)>
&cell_filter =
always_return<typename MeshType::active_cell_iterator, bool>{true});
template <typename DataType, typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void exchange_cell_data_to_level_ghosts(
- const MeshType & mesh,
+ const MeshType &mesh,
const std::function<std::optional<DataType>(
const typename MeshType::level_cell_iterator &)> &pack,
const std::function<void(const typename MeshType::level_cell_iterator &,
- const DataType &)> & unpack,
+ const DataType &)> &unpack,
const std::function<bool(const typename MeshType::level_cell_iterator &)> &
cell_filter = always_return<typename MeshType::level_cell_iterator, bool>{
true});
template <int dim, int spacedim>
void
collect_coinciding_vertices(
- const Triangulation<dim, spacedim> & tria,
+ const Triangulation<dim, spacedim> &tria,
std::map<unsigned int, std::vector<unsigned int>> &coinciding_vertex_groups,
std::map<unsigned int, unsigned int> &vertex_to_coinciding_vertex_group);
/**
* Constructor.
*/
- MarchingCubeAlgorithm(const Mapping<dim, dim> & mapping,
+ MarchingCubeAlgorithm(const Mapping<dim, dim> &mapping,
const FiniteElement<dim, dim> &fe,
const unsigned int n_subdivisions = 1,
const double tolerance = 1e-10);
* @note Duplicate vertices are not deleted.
*/
void
- process(const DoFHandler<dim> & background_dof_handler,
- const VectorType & ls_vector,
+ process(const DoFHandler<dim> &background_dof_handler,
+ const VectorType &ls_vector,
const double iso_level,
std::vector<Point<dim>> &vertices,
std::vector<CellData<dim == 1 ? 1 : dim - 1>> &cells) const;
* are cut.
*/
void
- process(const DoFHandler<dim> & background_dof_handler,
- const VectorType & ls_vector,
+ process(const DoFHandler<dim> &background_dof_handler,
+ const VectorType &ls_vector,
const double iso_level,
std::vector<Point<dim>> &vertices) const;
*/
void
process_cell(const typename DoFHandler<dim>::active_cell_iterator &cell,
- const VectorType & ls_vector,
+ const VectorType &ls_vector,
const double iso_level,
- std::vector<Point<dim>> & vertices,
+ std::vector<Point<dim>> &vertices,
std::vector<CellData<dim == 1 ? 1 : dim - 1>> &cells) const;
/**
* Process the provided cell and fill @p vertices for all cells that are cut.
*/
void
process_cell(const typename DoFHandler<dim>::active_cell_iterator &cell,
- const VectorType & ls_vector,
+ const VectorType &ls_vector,
const double iso_level,
std::vector<Point<dim>> &vertices) const;
* Process a cell.
*/
void
- process_cell(std::vector<value_type> & ls_values,
- const std::vector<Point<dim>> & points,
+ process_cell(std::vector<value_type> &ls_values,
+ const std::vector<Point<dim>> &points,
const double iso_level,
- std::vector<Point<dim>> & vertices,
+ std::vector<Point<dim>> &vertices,
std::vector<CellData<dim == 1 ? 1 : dim - 1>> &cells,
const bool write_back_cell_data = true) const;
* of subdivisions in this case.
*/
void
- process_sub_cell(const std::vector<value_type> & ls_values,
- const std::vector<Point<2>> & points,
+ process_sub_cell(const std::vector<value_type> &ls_values,
+ const std::vector<Point<2>> &points,
const std::vector<unsigned int> &mask,
const double iso_level,
- std::vector<Point<2>> & vertices,
- std::vector<CellData<1>> & cells,
+ std::vector<Point<2>> &vertices,
+ std::vector<CellData<1>> &cells,
const bool write_back_cell_data) const;
/**
* Process a sub-cell (3d).
*/
void
- process_sub_cell(const std::vector<value_type> & ls_values,
- const std::vector<Point<3>> & points,
+ process_sub_cell(const std::vector<value_type> &ls_values,
+ const std::vector<Point<3>> &points,
const std::vector<unsigned int> &mask,
const double iso_level,
- std::vector<Point<3>> & vertices,
- std::vector<CellData<2>> & cells,
+ std::vector<Point<3>> &vertices,
+ std::vector<CellData<2>> &cells,
const bool write_back_cell_data) const;
/**
std::assignable_from<
Point<spacedim> &,
std::invoke_result_t<Transformation, Point<spacedim>>>))
- void transform(const Transformation & transformation,
+ void transform(const Transformation &transformation,
Triangulation<dim, spacedim> &triangulation)
{
std::vector<bool> treated_vertices(triangulation.n_vertices(), false);
template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void get_active_neighbors(
- const typename MeshType::active_cell_iterator & cell,
+ const typename MeshType::active_cell_iterator &cell,
std::vector<typename MeshType::active_cell_iterator> &active_neighbors)
{
active_neighbors.clear();
const Point<spacedim> &p0,
const Tensor<1, GeometryInfo<structdim>::vertices_per_cell> ¢er,
const double step,
- const F & f)
+ const F &f)
{
Assert(row_n < GeometryInfo<structdim>::vertices_per_cell &&
dependent_direction <
*/
template <typename Iterator, int spacedim, int structdim>
Point<spacedim>
- project_to_d_linear_object(const Iterator & object,
+ project_to_d_linear_object(const Iterator &object,
const Point<spacedim> &trial_point)
{
// let's look at this for simplicity for a quadrilateral
template <typename Iterator>
Point<Iterator::AccessorType::space_dimension>
project_to_object(
- const Iterator & object,
+ const Iterator &object,
const Point<Iterator::AccessorType::space_dimension> &trial_point)
{
const int spacedim = Iterator::AccessorType::space_dimension;
const std::function<std::optional<DataType>(const MeshCellIteratorType &)>
&pack,
const std::function<void(const MeshCellIteratorType &, const DataType &)>
- & unpack,
- const std::function<bool(const MeshCellIteratorType &)> & cell_filter,
+ &unpack,
+ const std::function<bool(const MeshCellIteratorType &)> &cell_filter,
const std::function<void(
const std::function<void(const MeshCellIteratorType &,
const types::subdomain_id)> &)> &process_cells,
template <typename DataType, typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
inline void exchange_cell_data_to_ghosts(
- const MeshType & mesh,
+ const MeshType &mesh,
const std::function<std::optional<DataType>(
const typename MeshType::active_cell_iterator &)> &pack,
const std::function<void(const typename MeshType::active_cell_iterator &,
- const DataType &)> & unpack,
+ const DataType &)> &unpack,
const std::function<bool(const typename MeshType::active_cell_iterator &)>
&cell_filter)
{
template <typename DataType, typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
inline void exchange_cell_data_to_level_ghosts(
- const MeshType & mesh,
+ const MeshType &mesh,
const std::function<std::optional<DataType>(
const typename MeshType::level_cell_iterator &)> &pack,
const std::function<void(const typename MeshType::level_cell_iterator &,
- const DataType &)> & unpack,
+ const DataType &)> &unpack,
const std::function<bool(const typename MeshType::level_cell_iterator &)>
&cell_filter)
{
* @param mapping The mapping to use when computing cached objects
*/
Cache(const Triangulation<dim, spacedim> &tria,
- const Mapping<dim, spacedim> & mapping =
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()
*/
virtual Point<spacedim>
get_new_point(const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights) const;
+ const ArrayView<const double> &weights) const;
/**
*/
virtual void
get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
- const Table<2, double> & weights,
+ const Table<2, double> &weights,
ArrayView<Point<spacedim>> new_points) const;
/**
virtual Point<spacedim>
project_to_manifold(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Point<spacedim> & candidate) const;
+ const Point<spacedim> &candidate) const;
/**
* Backward compatibility interface. Return the point which shall become
virtual Tensor<1, spacedim>
normal_vector(
const typename Triangulation<dim, spacedim>::face_iterator &face,
- const Point<spacedim> & p) const;
+ const Point<spacedim> &p) const;
/**
* Compute the normal vectors to the boundary at each vertex of the
*/
virtual Point<spacedim>
get_new_point(const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights) const override;
+ const ArrayView<const double> &weights) const override;
/**
*/
virtual void
get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
- const Table<2, double> & weights,
+ const Table<2, double> &weights,
ArrayView<Point<spacedim>> new_points) const override;
/**
*/
virtual Point<spacedim>
get_new_point(const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights) const override;
+ const ArrayView<const double> &weights) const override;
/**
* Compute a new set of points that interpolate between the given points @p
*/
virtual void
get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
- const Table<2, double> & weights,
+ const Table<2, double> &weights,
ArrayView<Point<spacedim>> new_points) const override;
/**
* Pull back the given point in spacedim to the Euclidean chartdim
*/
virtual void
get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
- const Table<2, double> & weights,
+ const Table<2, double> &weights,
ArrayView<Point<spacedim>> new_points) const override;
/**
*/
virtual Point<spacedim>
get_new_point(const ArrayView<const Point<spacedim>> &vertices,
- const ArrayView<const double> & weights) const override;
+ const ArrayView<const double> &weights) const override;
/**
* The center of the spherical coordinate system.
*/
std::pair<double, Tensor<1, spacedim>>
guess_new_point(const ArrayView<const Tensor<1, spacedim>> &directions,
- const ArrayView<const double> & distances,
- const ArrayView<const double> & weights) const;
+ const ArrayView<const double> &distances,
+ const ArrayView<const double> &weights) const;
/**
* Return a point on the spherical manifold which is intermediate
*/
Point<spacedim>
get_new_point(const ArrayView<const Tensor<1, spacedim>> &directions,
- const ArrayView<const double> & distances,
- const ArrayView<const double> & weights,
+ const ArrayView<const double> &distances,
+ const ArrayView<const double> &weights,
const Point<spacedim> &candidate_point) const;
/**
*/
virtual void
get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights,
+ const ArrayView<const double> &weights,
ArrayView<Point<spacedim>> new_points) const;
/**
* value is used to determine if a point is on the axis.
*/
CylindricalManifold(const Tensor<1, spacedim> &direction,
- const Point<spacedim> & point_on_axis,
+ const Point<spacedim> &point_on_axis,
const double tolerance = 1e-10);
/**
*/
virtual Point<spacedim>
get_new_point(const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights) const override;
+ const ArrayView<const double> &weights) const override;
private:
/**
* @param eccentricity Eccentricity of the
* manifold $e\in\left]0,1\right[$.
*/
- EllipticalManifold(const Point<spacedim> & center,
+ EllipticalManifold(const Point<spacedim> ¢er,
const Tensor<1, spacedim> &major_axis_direction,
const double eccentricity);
* the function objects are destroyed only after the constructed manifold.
*/
FunctionManifold(
- const Function<chartdim> & push_forward_function,
- const Function<spacedim> & pull_back_function,
+ const Function<chartdim> &push_forward_function,
+ const Function<spacedim> &pull_back_function,
const Tensor<1, chartdim> &periodicity = Tensor<1, chartdim>(),
const double tolerance = 1e-10);
FunctionManifold(
std::unique_ptr<Function<chartdim>> push_forward,
std::unique_ptr<Function<spacedim>> pull_back,
- const Tensor<1, chartdim> & periodicity = Tensor<1, chartdim>(),
+ const Tensor<1, chartdim> &periodicity = Tensor<1, chartdim>(),
const double tolerance = 1e-10);
/**
*/
virtual Point<spacedim>
get_new_point(const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights) const override;
+ const ArrayView<const double> &weights) const override;
/**
* Compute a new set of points that interpolate between the given points @p
*/
virtual void
get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
- const Table<2, double> & weights,
+ const Table<2, double> &weights,
ArrayView<Point<spacedim>> new_points) const override;
private:
*/
Point<dim>
pull_back(const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const Point<dim> &initial_guess) const;
/**
DerivativeForm<1, dim, spacedim>
push_forward_gradient(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<dim> & chart_point,
+ const Point<dim> &chart_point,
const Point<spacedim> &pushed_forward_chart_point) const;
/**
*/
virtual void
create_triangulation(const std::vector<Point<spacedim>> &vertices,
- const std::vector<CellData<dim>> & cells,
+ const std::vector<CellData<dim>> &cells,
const SubCellData &subcelldata) override;
/**
*/
template <int dim>
Tensor<1, dim>
- d_linear_shape_function_gradient(const Point<dim> & xi,
+ d_linear_shape_function_gradient(const Point<dim> &xi,
const unsigned int i) const;
/**
template <int dim>
inline double
-ReferenceCell::d_linear_shape_function(const Point<dim> & xi,
+ReferenceCell::d_linear_shape_function(const Point<dim> &xi,
const unsigned int i) const
{
AssertDimension(dim, get_dimension());
template <int dim>
inline Tensor<1, dim>
-ReferenceCell::d_linear_shape_function_gradient(const Point<dim> & xi,
+ReferenceCell::d_linear_shape_function_gradient(const Point<dim> &xi,
const unsigned int i) const
{
AssertDimension(dim, get_dimension());
/**
* Constructor.
*/
- NoPermutation(const ReferenceCell & entity_type,
+ NoPermutation(const ReferenceCell &entity_type,
const ArrayView<const T> &vertices_0,
const ArrayView<const T> &vertices_1)
: entity_type(entity_type)
template <int dim1, int dim2>
void
split_point(const Point<dim1 + dim2> &source,
- Point<dim1> & p1,
- Point<dim2> & p2)
+ Point<dim1> &p1,
+ Point<dim2> &p2)
{
for (unsigned int d = 0; d < dim1; ++d)
p1[d] = source[d];
&pack_callbacks_fixed,
const std::vector<
typename internal::CellAttachedData<dim, spacedim>::pack_callback_t>
- & pack_callbacks_variable,
+ &pack_callbacks_variable,
const MPI_Comm &mpi_communicator);
/**
save(const unsigned int global_first_cell,
const unsigned int global_num_cells,
const std::string &filename,
- const MPI_Comm & mpi_communicator) const;
+ const MPI_Comm &mpi_communicator) const;
/**
* Deserialize data from file system.
const std::string &filename,
const unsigned int n_attached_deserialize_fixed,
const unsigned int n_attached_deserialize_variable,
- const MPI_Comm & mpi_communicator);
+ const MPI_Comm &mpi_communicator);
/**
* Clears all containers and associated data, and resets member
*/
virtual void
create_triangulation(const std::vector<Point<spacedim>> &vertices,
- const std::vector<CellData<dim>> & cells,
- const SubCellData & subcelldata);
+ const std::vector<CellData<dim>> &cells,
+ const SubCellData &subcelldata);
/**
* Create a triangulation from the provided
register_data_attach(
const std::function<std::vector<char>(const cell_iterator &,
const ::dealii::CellStatus)>
- & pack_callback,
+ &pack_callback,
const bool returns_variable_size_data);
/**
write_bool_vector(const unsigned int magic_number1,
const std::vector<bool> &v,
const unsigned int magic_number2,
- std::ostream & out);
+ std::ostream &out);
/**
* Re-read a vector of bools previously written by @p write_bool_vector and
read_bool_vector(const unsigned int magic_number1,
std::vector<bool> &v,
const unsigned int magic_number2,
- std::istream & in);
+ std::istream &in);
/**
* Recreate information about periodic neighbors from
void
NumberCache<1>::serialize(Archive &ar, const unsigned int)
{
- ar &n_levels;
- ar &n_lines &n_lines_level;
+ ar &n_levels;
+ ar &n_lines &n_lines_level;
ar &n_active_lines &n_active_lines_level;
}
{
this->NumberCache<1>::serialize(ar, version);
- ar &n_quads &n_quads_level;
+ ar &n_quads &n_quads_level;
ar &n_active_quads &n_active_quads_level;
}
{
this->NumberCache<2>::serialize(ar, version);
- ar &n_hexes &n_hexes_level;
+ ar &n_hexes &n_hexes_level;
ar &n_active_hexes &n_active_hexes_level;
}
ar &smooth_grid;
unsigned int n_levels = levels.size();
- ar & n_levels;
+ ar &n_levels;
for (const auto &level : levels)
ar &level;
// at least up to 1.65.1. This causes problems with clang-5.
// Therefore, work around it.
bool faces_is_nullptr = (faces.get() == nullptr);
- ar & faces_is_nullptr;
+ ar &faces_is_nullptr;
if (!faces_is_nullptr)
ar &faces;
ar &smooth_grid;
unsigned int size;
- ar & size;
+ ar &size;
levels.resize(size);
for (auto &level_ : levels)
{
std::unique_ptr<internal::TriangulationImplementation::TriaLevel> level;
- ar & level;
+ ar &level;
level_ = std::move(level);
}
// Workaround for nullptr, see in save().
bool faces_is_nullptr = true;
- ar & faces_is_nullptr;
+ ar &faces_is_nullptr;
if (!faces_is_nullptr)
ar &faces;
reset_policy();
bool my_check_for_distorted_cells;
- ar & my_check_for_distorted_cells;
+ ar &my_check_for_distorted_cells;
Assert(my_check_for_distorted_cells == check_for_distorted_cells,
ExcMessage("The triangulation loaded into here must have the "
TriaAccessorBase(const Triangulation<dim, spacedim> *parent = nullptr,
const int level = -1,
const int index = -1,
- const AccessorData * = nullptr);
+ const AccessorData * = nullptr);
/**
* Copy constructor. Creates an object with exactly the same data.
* semantic sense, and we generate an exception when such an object is
* actually generated.
*/
- InvalidAccessor(const void * parent = nullptr,
+ InvalidAccessor(const void *parent = nullptr,
const int level = -1,
const int index = -1,
const AccessorData *local_data = nullptr);
TriaAccessor(const Triangulation<dim, spacedim> *parent = nullptr,
const int level = -1,
const int index = -1,
- const AccessorData * local_data = nullptr);
+ const AccessorData *local_data = nullptr);
/**
* The copy constructor is not deleted but copied constructed elements should
TriaAccessor(const Triangulation<dim, spacedim> *tria = nullptr,
const int level = 0,
const int index = 0,
- const AccessorData * = nullptr);
+ const AccessorData * = nullptr);
/**
* Constructor. Should never be called and thus produces an error.
TriaAccessor(const Triangulation<1, spacedim> *tria = nullptr,
const int = 0,
const int = 0,
- const AccessorData * = nullptr);
+ const AccessorData * = nullptr);
/**
* Constructor. Should never be called and thus produces an error.
CellAccessor(const Triangulation<dim, spacedim> *parent = nullptr,
const int level = -1,
const int index = -1,
- const AccessorData * local_data = nullptr);
+ const AccessorData *local_data = nullptr);
/**
* Copy constructor.
const Triangulation<dim, spacedim> *parent,
const int level,
const int index,
- const AccessorData * local_data)
+ const AccessorData *local_data)
: TriaAccessorBase<structdim, dim, spacedim>(parent, level, index, local_data)
{}
const Triangulation<dim, spacedim> *parent,
const int level,
const int index,
- const AccessorData * local_data)
+ const AccessorData *local_data)
: TriaAccessor<dim, dim, spacedim>(parent, level, index, local_data)
{}
create_description_from_triangulation(
const Triangulation<dim, spacedim> &tria,
const LinearAlgebra::distributed::Vector<double, MemorySpace::Host>
- & partition,
+ &partition,
const TriangulationDescription::Settings settings =
TriangulationDescription::Settings::default_setting);
&partition,
const std::vector<
LinearAlgebra::distributed::Vector<double, MemorySpace::Host>>
- & mg_partitions,
+ &mg_partitions,
const TriangulationDescription::Settings settings =
TriangulationDescription::Settings::default_setting);
Description<dim, spacedim>
create_description_from_triangulation_in_groups(
const std::function<void(dealii::Triangulation<dim, spacedim> &)>
- & serial_grid_generator,
+ &serial_grid_generator,
const std::function<void(dealii::Triangulation<dim, spacedim> &,
const MPI_Comm,
const unsigned int)> &serial_grid_partitioner,
void
TriaFaces::serialize(Archive &ar, const unsigned int)
{
- ar &dim;
+ ar &dim;
ar &quads &lines &quads_line_orientations &quad_is_quadrilateral;
}
} // namespace TriangulationImplementation
const TriaAccessorBase<Accessor::structure_dimension,
Accessor::dimension,
Accessor::space_dimension> &tria_accessor,
- const typename Accessor::AccessorData * local_data);
+ const typename Accessor::AccessorData *local_data);
/**
* Conversion constructor. Same as above with the difference that it
TriaIterator(const TriaAccessorBase<Accessor::structure_dimension,
Accessor::dimension,
Accessor::space_dimension> &tria_accessor,
- const typename Accessor::AccessorData * local_data);
+ const typename Accessor::AccessorData *local_data);
/**
* Similar conversion operator to the above one, but does a check whether
const TriaAccessorBase<Accessor::structure_dimension,
Accessor::dimension,
Accessor::space_dimension> &tria_accessor,
- const typename Accessor::AccessorData * local_data);
+ const typename Accessor::AccessorData *local_data);
/**
* Similar conversion operator to the above one, but does a check whether
const TriaAccessorBase<Accessor::structure_dimension,
Accessor::dimension,
Accessor::space_dimension> &tria_accessor,
- const typename Accessor::AccessorData * local_data)
+ const typename Accessor::AccessorData *local_data)
: accessor(nullptr, -2, -2, local_data)
{
accessor.copy_from(tria_accessor);
TriaRawIterator<Accessor>::operator++(int)
{
TriaRawIterator<Accessor> tmp(*this);
- operator++();
+ operator++();
return tmp;
}
TriaRawIterator<Accessor>::operator--(int)
{
TriaRawIterator<Accessor> tmp(*this);
- operator--();
+ operator--();
return tmp;
}
const TriaAccessorBase<Accessor::structure_dimension,
Accessor::dimension,
Accessor::space_dimension> &tria_accessor,
- const typename Accessor::AccessorData * local_data)
+ const typename Accessor::AccessorData *local_data)
: TriaRawIterator<Accessor>(tria_accessor, local_data)
{
#ifdef DEBUG
TriaIterator<Accessor>::operator++(int)
{
TriaIterator<Accessor> tmp(*this);
- operator++();
+ operator++();
return tmp;
}
TriaIterator<Accessor>::operator--(int)
{
TriaIterator<Accessor> tmp(*this);
- operator--();
+ operator--();
return tmp;
}
const TriaAccessorBase<Accessor::structure_dimension,
Accessor::dimension,
Accessor::space_dimension> &tria_accessor,
- const typename Accessor::AccessorData * local_data)
+ const typename Accessor::AccessorData *local_data)
: TriaIterator<Accessor>(tria_accessor, local_data)
{
#ifdef DEBUG
TriaActiveIterator<Accessor>::operator++(int)
{
TriaActiveIterator<Accessor> tmp(*this);
- operator++();
+ operator++();
return tmp;
}
TriaActiveIterator<Accessor>::operator--(int)
{
TriaActiveIterator<Accessor> tmp(*this);
- operator--();
+ operator--();
return tmp;
}
void
TriaObjects::serialize(Archive &ar, const unsigned int)
{
- ar &structdim;
- ar &cells &children;
- ar & refinement_cases;
- ar & used;
- ar & user_flags;
- ar & boundary_or_material_id;
- ar & manifold_id;
+ ar &structdim;
+ ar &cells &children;
+ ar &refinement_cases;
+ ar &used;
+ ar &user_flags;
+ ar &boundary_or_material_id;
+ ar &manifold_id;
ar &next_free_single &next_free_pair &reverse_order_next_free_single;
- ar &user_data &user_data_type;
+ ar &user_data &user_data_type;
}
const MappingCollection<dim, FEValuesType::space_dimension>
&mapping_collection,
const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
- const QCollection<q_dim> & q_collection,
+ const QCollection<q_dim> &q_collection,
const UpdateFlags update_flags);
/**
const MappingCollection<dim, FEValuesType::space_dimension>
&mapping_collection,
const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
- const std::vector<QCollection<q_dim>> & q_collection,
+ const std::vector<QCollection<q_dim>> &q_collection,
const UpdateFlags update_flags);
/**
*/
FEValuesBase(
const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
- const QCollection<q_dim> & q_collection,
+ const QCollection<q_dim> &q_collection,
const UpdateFlags update_flags);
/**
*/
FEValuesBase(
const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
- const std::vector<QCollection<q_dim>> & q_collection,
+ const std::vector<QCollection<q_dim>> &q_collection,
const UpdateFlags update_flags);
/**
* Constructor. Initialize this object with the given parameters.
*/
FEValues(const MappingCollection<dim, spacedim> &mapping_collection,
- const FECollection<dim, spacedim> & fe_collection,
- const QCollection<dim> & q_collection,
+ const FECollection<dim, spacedim> &fe_collection,
+ const QCollection<dim> &q_collection,
const UpdateFlags update_flags);
* MappingQ(1)) implicitly.
*/
FEValues(const FECollection<dim, spacedim> &fe_collection,
- const QCollection<dim> & q_collection,
+ const QCollection<dim> &q_collection,
const UpdateFlags update_flags);
* Constructor. Initialize this object with the given parameters.
*/
FEFaceValues(const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const hp::FECollection<dim, spacedim> & fe_collection,
- const hp::QCollection<dim - 1> & q_collection,
+ const hp::FECollection<dim, spacedim> &fe_collection,
+ const hp::QCollection<dim - 1> &q_collection,
const UpdateFlags update_flags);
/**
* this quadrature rule is use on all faces.
*/
FEFaceValues(const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const hp::FECollection<dim, spacedim> & fe_collection,
+ const hp::FECollection<dim, spacedim> &fe_collection,
const std::vector<hp::QCollection<dim - 1>> &q_collections,
const UpdateFlags update_flags);
* MappingQ(1)) implicitly.
*/
FEFaceValues(const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim - 1> & q_collection,
+ const hp::QCollection<dim - 1> &q_collection,
const UpdateFlags update_flags);
/**
* In the case that the collections only contains a single face quadrature,
* this quadrature rule is use on all faces.
*/
- FEFaceValues(const hp::FECollection<dim, spacedim> & fe_collection,
+ FEFaceValues(const hp::FECollection<dim, spacedim> &fe_collection,
const std::vector<hp::QCollection<dim - 1>> &q_collections,
const UpdateFlags update_flags);
*/
template <bool lda>
void
- reinit(const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> & cell,
+ reinit(const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &cell,
const typename Triangulation<dim, spacedim>::face_iterator &face,
const unsigned int q_index = numbers::invalid_unsigned_int,
const unsigned int mapping_index = numbers::invalid_unsigned_int,
*/
FESubfaceValues(
const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const hp::FECollection<dim, spacedim> & fe_collection,
- const hp::QCollection<dim - 1> & q_collection,
+ const hp::FECollection<dim, spacedim> &fe_collection,
+ const hp::QCollection<dim - 1> &q_collection,
const UpdateFlags update_flags);
* MappingQ(1)) implicitly.
*/
FESubfaceValues(const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim - 1> & q_collection,
+ const hp::QCollection<dim - 1> &q_collection,
const UpdateFlags update_flags);
/**
template <int dim, int spacedim>
void
p_adaptivity_from_flags(const DoFHandler<dim, spacedim> &dof_handler,
- const std::vector<bool> & p_flags);
+ const std::vector<bool> &p_flags);
/**
* Adapt which finite element to use on cells whose criteria meet a certain
void
p_adaptivity_from_absolute_threshold(
const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const Number p_refine_threshold,
const Number p_coarsen_threshold,
const ComparisonFunction<std_cxx20::type_identity_t<Number>>
void
p_adaptivity_from_relative_threshold(
const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double p_refine_fraction = 0.5,
const double p_coarsen_fraction = 0.5,
const ComparisonFunction<std_cxx20::type_identity_t<Number>>
void
p_adaptivity_fixed_number(
const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double p_refine_fraction = 0.5,
const double p_coarsen_fraction = 0.5,
const ComparisonFunction<std_cxx20::type_identity_t<Number>>
void
p_adaptivity_from_reference(
const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & criteria,
- const Vector<Number> & references,
+ const Vector<Number> &criteria,
+ const Vector<Number> &references,
const ComparisonFunction<std_cxx20::type_identity_t<Number>>
&compare_refine,
const ComparisonFunction<std_cxx20::type_identity_t<Number>>
template <int dim, typename Number, int spacedim>
void
predict_error(const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & error_indicators,
- Vector<Number> & predicted_errors,
+ const Vector<Number> &error_indicators,
+ Vector<Number> &predicted_errors,
const double gamma_p = std::sqrt(0.4),
const double gamma_h = 2.,
const double gamma_n = 1.);
*/
template <int dim>
void
- cell_matrix(FullMatrix<double> & M,
- const FEValuesBase<dim> & fe,
- const FEValuesBase<dim> & fetest,
+ cell_matrix(FullMatrix<double> &M,
+ const FEValuesBase<dim> &fe,
+ const FEValuesBase<dim> &fetest,
const ArrayView<const std::vector<double>> &velocity,
const double factor = 1.)
{
*/
template <int dim>
inline void
- cell_residual(Vector<double> & result,
- const FEValuesBase<dim> & fe,
- const std::vector<Tensor<1, dim>> & input,
+ cell_residual(Vector<double> &result,
+ const FEValuesBase<dim> &fe,
+ const std::vector<Tensor<1, dim>> &input,
const ArrayView<const std::vector<double>> &velocity,
double factor = 1.)
{
*/
template <int dim>
inline void
- cell_residual(Vector<double> & result,
- const FEValuesBase<dim> & fe,
+ cell_residual(Vector<double> &result,
+ const FEValuesBase<dim> &fe,
const ArrayView<const std::vector<Tensor<1, dim>>> &input,
- const ArrayView<const std::vector<double>> & velocity,
+ const ArrayView<const std::vector<double>> &velocity,
double factor = 1.)
{
const unsigned int nq = fe.n_quadrature_points;
*/
template <int dim>
inline void
- cell_residual(Vector<double> & result,
- const FEValuesBase<dim> & fe,
- const std::vector<double> & input,
+ cell_residual(Vector<double> &result,
+ const FEValuesBase<dim> &fe,
+ const std::vector<double> &input,
const ArrayView<const std::vector<double>> &velocity,
double factor = 1.)
{
*/
template <int dim>
inline void
- cell_residual(Vector<double> & result,
- const FEValuesBase<dim> & fe,
+ cell_residual(Vector<double> &result,
+ const FEValuesBase<dim> &fe,
const ArrayView<const std::vector<double>> &input,
const ArrayView<const std::vector<double>> &velocity,
double factor = 1.)
*/
template <int dim>
void
- upwind_value_matrix(FullMatrix<double> & M,
- const FEValuesBase<dim> & fe,
- const FEValuesBase<dim> & fetest,
+ upwind_value_matrix(FullMatrix<double> &M,
+ const FEValuesBase<dim> &fe,
+ const FEValuesBase<dim> &fetest,
const ArrayView<const std::vector<double>> &velocity,
double factor = 1.)
{
*/
template <int dim>
inline void
- upwind_value_residual(Vector<double> & result,
- const FEValuesBase<dim> & fe,
- const std::vector<double> & input,
- const std::vector<double> & data,
+ upwind_value_residual(Vector<double> &result,
+ const FEValuesBase<dim> &fe,
+ const std::vector<double> &input,
+ const std::vector<double> &data,
const ArrayView<const std::vector<double>> &velocity,
double factor = 1.)
{
*/
template <int dim>
inline void
- upwind_value_residual(Vector<double> & result,
- const FEValuesBase<dim> & fe,
+ upwind_value_residual(Vector<double> &result,
+ const FEValuesBase<dim> &fe,
const ArrayView<const std::vector<double>> &input,
const ArrayView<const std::vector<double>> &data,
const ArrayView<const std::vector<double>> &velocity,
*/
template <int dim>
void
- upwind_value_matrix(FullMatrix<double> & M11,
- FullMatrix<double> & M12,
- FullMatrix<double> & M21,
- FullMatrix<double> & M22,
- const FEValuesBase<dim> & fe1,
- const FEValuesBase<dim> & fe2,
- const FEValuesBase<dim> & fetest1,
- const FEValuesBase<dim> & fetest2,
+ upwind_value_matrix(FullMatrix<double> &M11,
+ FullMatrix<double> &M12,
+ FullMatrix<double> &M21,
+ FullMatrix<double> &M22,
+ const FEValuesBase<dim> &fe1,
+ const FEValuesBase<dim> &fe2,
+ const FEValuesBase<dim> &fetest1,
+ const FEValuesBase<dim> &fetest2,
const ArrayView<const std::vector<double>> &velocity,
const double factor = 1.)
{
*/
template <int dim>
void
- upwind_face_residual(Vector<double> & result1,
- Vector<double> & result2,
- const FEValuesBase<dim> & fe1,
- const FEValuesBase<dim> & fe2,
- const std::vector<double> & input1,
- const std::vector<double> & input2,
+ upwind_face_residual(Vector<double> &result1,
+ Vector<double> &result2,
+ const FEValuesBase<dim> &fe1,
+ const FEValuesBase<dim> &fe2,
+ const std::vector<double> &input1,
+ const std::vector<double> &input2,
const ArrayView<const std::vector<double>> &velocity,
const double factor = 1.)
{
*/
template <int dim>
void
- upwind_face_residual(Vector<double> & result1,
- Vector<double> & result2,
- const FEValuesBase<dim> & fe1,
- const FEValuesBase<dim> & fe2,
+ upwind_face_residual(Vector<double> &result1,
+ Vector<double> &result2,
+ const FEValuesBase<dim> &fe1,
+ const FEValuesBase<dim> &fe2,
const ArrayView<const std::vector<double>> &input1,
const ArrayView<const std::vector<double>> &input2,
const ArrayView<const std::vector<double>> &velocity,
*/
template <int dim>
void
- cell_matrix(FullMatrix<double> & M,
+ cell_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
const FEValuesBase<dim> &fetest,
double factor = 1.)
*/
template <int dim, typename number>
void
- cell_residual(Vector<number> & result,
- const FEValuesBase<dim> & fetest,
+ cell_residual(Vector<number> &result,
+ const FEValuesBase<dim> &fetest,
const ArrayView<const std::vector<Tensor<1, dim>>> &input,
const double factor = 1.)
{
*/
template <int dim, typename number>
void
- cell_residual(Vector<number> & result,
- const FEValuesBase<dim> & fetest,
+ cell_residual(Vector<number> &result,
+ const FEValuesBase<dim> &fetest,
const ArrayView<const std::vector<double>> &input,
const double factor = 1.)
{
*/
template <int dim>
void
- gradient_matrix(FullMatrix<double> & M,
+ gradient_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
const FEValuesBase<dim> &fetest,
double factor = 1.)
*/
template <int dim, typename number>
void
- gradient_residual(Vector<number> & result,
- const FEValuesBase<dim> & fetest,
+ gradient_residual(Vector<number> &result,
+ const FEValuesBase<dim> &fetest,
const std::vector<Tensor<1, dim>> &input,
const double factor = 1.)
{
*/
template <int dim, typename number>
void
- gradient_residual(Vector<number> & result,
- const FEValuesBase<dim> & fetest,
+ gradient_residual(Vector<number> &result,
+ const FEValuesBase<dim> &fetest,
const std::vector<double> &input,
const double factor = 1.)
{
*/
template <int dim>
void
- u_dot_n_matrix(FullMatrix<double> & M,
+ u_dot_n_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
const FEValuesBase<dim> &fetest,
double factor = 1.)
*/
template <int dim, typename number>
void
- u_dot_n_residual(Vector<number> & result,
- const FEValuesBase<dim> & fe,
- const FEValuesBase<dim> & fetest,
+ u_dot_n_residual(Vector<number> &result,
+ const FEValuesBase<dim> &fe,
+ const FEValuesBase<dim> &fetest,
const ArrayView<const std::vector<double>> &data,
double factor = 1.)
{
*/
template <int dim, typename number>
void
- u_times_n_residual(Vector<number> & result,
- const FEValuesBase<dim> & fetest,
+ u_times_n_residual(Vector<number> &result,
+ const FEValuesBase<dim> &fetest,
const std::vector<double> &data,
double factor = 1.)
{
*/
template <int dim>
void
- u_dot_n_matrix(FullMatrix<double> & M11,
- FullMatrix<double> & M12,
- FullMatrix<double> & M21,
- FullMatrix<double> & M22,
+ u_dot_n_matrix(FullMatrix<double> &M11,
+ FullMatrix<double> &M12,
+ FullMatrix<double> &M21,
+ FullMatrix<double> &M22,
const FEValuesBase<dim> &fe1,
const FEValuesBase<dim> &fe2,
const FEValuesBase<dim> &fetest1,
*/
template <int dim>
void
- u_dot_n_jump_matrix(FullMatrix<double> & M11,
- FullMatrix<double> & M12,
- FullMatrix<double> & M21,
- FullMatrix<double> & M22,
+ u_dot_n_jump_matrix(FullMatrix<double> &M11,
+ FullMatrix<double> &M12,
+ FullMatrix<double> &M21,
+ FullMatrix<double> &M22,
const FEValuesBase<dim> &fe1,
const FEValuesBase<dim> &fe2,
double factor = 1.)
*/
template <int dim>
double
- norm(const FEValuesBase<dim> & fe,
+ norm(const FEValuesBase<dim> &fe,
const ArrayView<const std::vector<Tensor<1, dim>>> &Du)
{
AssertDimension(fe.get_fe().n_components(), dim);
*/
template <int dim>
inline void
- cell_matrix(FullMatrix<double> & M,
+ cell_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
const double factor = 1.)
{
*/
template <int dim, typename number>
inline void
- cell_residual(Vector<number> & result,
- const FEValuesBase<dim> & fe,
+ cell_residual(Vector<number> &result,
+ const FEValuesBase<dim> &fe,
const ArrayView<const std::vector<Tensor<1, dim>>> &input,
double factor = 1.)
{
*/
template <int dim>
inline void
- nitsche_matrix(FullMatrix<double> & M,
+ nitsche_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
double penalty,
double factor = 1.)
*/
template <int dim>
inline void
- nitsche_tangential_matrix(FullMatrix<double> & M,
+ nitsche_tangential_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
double penalty,
double factor = 1.)
*/
template <int dim, typename number>
void
- nitsche_residual(Vector<number> & result,
- const FEValuesBase<dim> & fe,
- const ArrayView<const std::vector<double>> & input,
+ nitsche_residual(Vector<number> &result,
+ const FEValuesBase<dim> &fe,
+ const ArrayView<const std::vector<double>> &input,
const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput,
- const ArrayView<const std::vector<double>> & data,
+ const ArrayView<const std::vector<double>> &data,
double penalty,
double factor = 1.)
{
template <int dim, typename number>
inline void
nitsche_tangential_residual(
- Vector<number> & result,
- const FEValuesBase<dim> & fe,
- const ArrayView<const std::vector<double>> & input,
+ Vector<number> &result,
+ const FEValuesBase<dim> &fe,
+ const ArrayView<const std::vector<double>> &input,
const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput,
- const ArrayView<const std::vector<double>> & data,
+ const ArrayView<const std::vector<double>> &data,
double penalty,
double factor = 1.)
{
template <int dim, typename number>
void
nitsche_residual_homogeneous(
- Vector<number> & result,
- const FEValuesBase<dim> & fe,
- const ArrayView<const std::vector<double>> & input,
+ Vector<number> &result,
+ const FEValuesBase<dim> &fe,
+ const ArrayView<const std::vector<double>> &input,
const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput,
double penalty,
double factor = 1.)
*/
template <int dim>
inline void
- ip_matrix(FullMatrix<double> & M11,
- FullMatrix<double> & M12,
- FullMatrix<double> & M21,
- FullMatrix<double> & M22,
+ ip_matrix(FullMatrix<double> &M11,
+ FullMatrix<double> &M12,
+ FullMatrix<double> &M21,
+ FullMatrix<double> &M22,
const FEValuesBase<dim> &fe1,
const FEValuesBase<dim> &fe2,
const double pen,
*/
template <int dim, typename number>
void
- ip_residual(Vector<number> & result1,
- Vector<number> & result2,
- const FEValuesBase<dim> & fe1,
- const FEValuesBase<dim> & fe2,
- const ArrayView<const std::vector<double>> & input1,
+ ip_residual(Vector<number> &result1,
+ Vector<number> &result2,
+ const FEValuesBase<dim> &fe1,
+ const FEValuesBase<dim> &fe2,
+ const ArrayView<const std::vector<double>> &input1,
const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput1,
- const ArrayView<const std::vector<double>> & input2,
+ const ArrayView<const std::vector<double>> &input2,
const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput2,
double pen,
double int_factor = 1.,
*/
template <int dim>
void
- cell_matrix(FullMatrix<double> & M,
+ cell_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
double factor = 1.)
{
*/
template <int dim, typename number>
void
- cell_residual(Vector<number> & result,
- const FEValuesBase<dim> & fetest,
+ cell_residual(Vector<number> &result,
+ const FEValuesBase<dim> &fetest,
const ArrayView<const std::vector<Tensor<1, dim>>> &input,
const double factor = 1.)
{
*/
template <int dim>
inline void
- nitsche_matrix(FullMatrix<double> & M,
+ nitsche_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
double penalty,
double factor = 1.)
*/
template <int dim>
void
- nitsche_residual(Vector<double> & result,
- const FEValuesBase<dim> & fe,
- const ArrayView<const std::vector<double>> & input,
+ nitsche_residual(Vector<double> &result,
+ const FEValuesBase<dim> &fe,
+ const ArrayView<const std::vector<double>> &input,
const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput,
- const ArrayView<const std::vector<double>> & data,
+ const ArrayView<const std::vector<double>> &data,
double penalty,
double factor = 1.)
{
template <int dim>
void
- ip_matrix(FullMatrix<double> & M11,
- FullMatrix<double> & M12,
- FullMatrix<double> & M21,
- FullMatrix<double> & M22,
+ ip_matrix(FullMatrix<double> &M11,
+ FullMatrix<double> &M12,
+ FullMatrix<double> &M21,
+ FullMatrix<double> &M22,
const FEValuesBase<dim> &fe1,
const FEValuesBase<dim> &fe2,
double penalty,
*/
template <int dim>
void
- ip_residual(Vector<double> & result1,
- Vector<double> & result2,
- const FEValuesBase<dim> & fe1,
- const FEValuesBase<dim> & fe2,
- const ArrayView<const std::vector<double>> & input1,
+ ip_residual(Vector<double> &result1,
+ Vector<double> &result2,
+ const FEValuesBase<dim> &fe1,
+ const FEValuesBase<dim> &fe2,
+ const ArrayView<const std::vector<double>> &input1,
const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput1,
- const ArrayView<const std::vector<double>> & input2,
+ const ArrayView<const std::vector<double>> &input2,
const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput2,
double pen,
double int_factor = 1.,
*/
template <int dim>
void
- mass_matrix(FullMatrix<double> & M,
+ mass_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
const double factor = 1.)
{
*/
template <int dim>
void
- weighted_mass_matrix(FullMatrix<double> & M,
- const FEValuesBase<dim> & fe,
+ weighted_mass_matrix(FullMatrix<double> &M,
+ const FEValuesBase<dim> &fe,
const std::vector<double> &weights)
{
const unsigned int n_dofs = fe.dofs_per_cell;
*/
template <int dim, typename number>
void
- L2(Vector<number> & result,
- const FEValuesBase<dim> & fe,
+ L2(Vector<number> &result,
+ const FEValuesBase<dim> &fe,
const std::vector<double> &input,
const double factor = 1.)
{
*/
template <int dim, typename number>
void
- L2(Vector<number> & result,
- const FEValuesBase<dim> & fe,
+ L2(Vector<number> &result,
+ const FEValuesBase<dim> &fe,
const ArrayView<const std::vector<double>> &input,
const double factor = 1.)
{
*/
template <int dim>
void
- jump_matrix(FullMatrix<double> & M11,
- FullMatrix<double> & M12,
- FullMatrix<double> & M21,
- FullMatrix<double> & M22,
+ jump_matrix(FullMatrix<double> &M11,
+ FullMatrix<double> &M12,
+ FullMatrix<double> &M21,
+ FullMatrix<double> &M22,
const FEValuesBase<dim> &fe1,
const FEValuesBase<dim> &fe2,
const double factor1 = 1.,
*/
template <int dim>
void
- cell_matrix(FullMatrix<double> & M,
+ cell_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
const double factor = 1.)
{
*/
template <int dim>
inline void
- cell_residual(Vector<double> & result,
- const FEValuesBase<dim> & fe,
+ cell_residual(Vector<double> &result,
+ const FEValuesBase<dim> &fe,
const std::vector<Tensor<1, dim>> &input,
double factor = 1.)
{
*/
template <int dim>
inline void
- cell_residual(Vector<double> & result,
- const FEValuesBase<dim> & fe,
+ cell_residual(Vector<double> &result,
+ const FEValuesBase<dim> &fe,
const ArrayView<const std::vector<Tensor<1, dim>>> &input,
double factor = 1.)
{
*/
template <int dim>
void
- nitsche_matrix(FullMatrix<double> & M,
+ nitsche_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
double penalty,
double factor = 1.)
*/
template <int dim>
void
- nitsche_tangential_matrix(FullMatrix<double> & M,
+ nitsche_tangential_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
double penalty,
double factor = 1.)
*/
template <int dim>
void
- nitsche_residual(Vector<double> & result,
- const FEValuesBase<dim> & fe,
- const std::vector<double> & input,
+ nitsche_residual(Vector<double> &result,
+ const FEValuesBase<dim> &fe,
+ const std::vector<double> &input,
const std::vector<Tensor<1, dim>> &Dinput,
- const std::vector<double> & data,
+ const std::vector<double> &data,
double penalty,
double factor = 1.)
{
*/
template <int dim>
void
- nitsche_residual(Vector<double> & result,
- const FEValuesBase<dim> & fe,
- const ArrayView<const std::vector<double>> & input,
+ nitsche_residual(Vector<double> &result,
+ const FEValuesBase<dim> &fe,
+ const ArrayView<const std::vector<double>> &input,
const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput,
- const ArrayView<const std::vector<double>> & data,
+ const ArrayView<const std::vector<double>> &data,
double penalty,
double factor = 1.)
{
*/
template <int dim>
void
- ip_matrix(FullMatrix<double> & M11,
- FullMatrix<double> & M12,
- FullMatrix<double> & M21,
- FullMatrix<double> & M22,
+ ip_matrix(FullMatrix<double> &M11,
+ FullMatrix<double> &M12,
+ FullMatrix<double> &M21,
+ FullMatrix<double> &M22,
const FEValuesBase<dim> &fe1,
const FEValuesBase<dim> &fe2,
double penalty,
*/
template <int dim>
void
- ip_tangential_matrix(FullMatrix<double> & M11,
- FullMatrix<double> & M12,
- FullMatrix<double> & M21,
- FullMatrix<double> & M22,
+ ip_tangential_matrix(FullMatrix<double> &M11,
+ FullMatrix<double> &M12,
+ FullMatrix<double> &M21,
+ FullMatrix<double> &M22,
const FEValuesBase<dim> &fe1,
const FEValuesBase<dim> &fe2,
double penalty,
*/
template <int dim>
void
- ip_residual(Vector<double> & result1,
- Vector<double> & result2,
- const FEValuesBase<dim> & fe1,
- const FEValuesBase<dim> & fe2,
- const std::vector<double> & input1,
+ ip_residual(Vector<double> &result1,
+ Vector<double> &result2,
+ const FEValuesBase<dim> &fe1,
+ const FEValuesBase<dim> &fe2,
+ const std::vector<double> &input1,
const std::vector<Tensor<1, dim>> &Dinput1,
- const std::vector<double> & input2,
+ const std::vector<double> &input2,
const std::vector<Tensor<1, dim>> &Dinput2,
double pen,
double int_factor = 1.,
*/
template <int dim>
void
- ip_residual(Vector<double> & result1,
- Vector<double> & result2,
- const FEValuesBase<dim> & fe1,
- const FEValuesBase<dim> & fe2,
- const ArrayView<const std::vector<double>> & input1,
+ ip_residual(Vector<double> &result1,
+ Vector<double> &result2,
+ const FEValuesBase<dim> &fe1,
+ const FEValuesBase<dim> &fe2,
+ const ArrayView<const std::vector<double>> &input1,
const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput1,
- const ArrayView<const std::vector<double>> & input2,
+ const ArrayView<const std::vector<double>> &input2,
const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput2,
double pen,
double int_factor = 1.,
*/
template <int dim>
void
- curl_curl_matrix(FullMatrix<double> & M,
+ curl_curl_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
const double factor = 1.)
{
*/
template <int dim>
void
- curl_matrix(FullMatrix<double> & M,
+ curl_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
const FEValuesBase<dim> &fetest,
double factor = 1.)
*/
template <int dim>
void
- nitsche_curl_matrix(FullMatrix<double> & M,
+ nitsche_curl_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
const unsigned int face_no,
double penalty,
*/
template <int dim>
void
- tangential_trace_matrix(FullMatrix<double> & M,
+ tangential_trace_matrix(FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
double factor = 1.)
{
*/
template <int dim>
inline void
- ip_curl_matrix(FullMatrix<double> & M11,
- FullMatrix<double> & M12,
- FullMatrix<double> & M21,
- FullMatrix<double> & M22,
+ ip_curl_matrix(FullMatrix<double> &M11,
+ FullMatrix<double> &M12,
+ FullMatrix<double> &M21,
+ FullMatrix<double> &M22,
const FEValuesBase<dim> &fe1,
const FEValuesBase<dim> &fe2,
const double pen,
{
template <int dim>
inline void
- points_and_values(Table<2, double> & result,
- const FEValuesBase<dim> & fe,
+ points_and_values(Table<2, double> &result,
+ const FEValuesBase<dim> &fe,
const ArrayView<const std::vector<double>> &input)
{
const unsigned int n_comp = fe.get_fe().n_components();
template <typename VectorType>
void
set_zero_all(const std::vector<types::global_dof_index> &cm,
- VectorType & vec);
+ VectorType &vec);
template <class T>
void
set_zero_all(const std::vector<types::global_dof_index> &cm,
- dealii::Vector<T> & vec);
+ dealii::Vector<T> &vec);
template <class T>
void
set_zero_all(const std::vector<types::global_dof_index> &cm,
- dealii::BlockVector<T> & vec);
+ dealii::BlockVector<T> &vec);
} // namespace AffineConstraintsImplementation
} // namespace internal
#endif
*/
void
add_selected_constraints(const AffineConstraints &constraints_in,
- const IndexSet & filter);
+ const IndexSet &filter);
/**
* @name Adding constraints
*/
template <class InVector, class OutVector>
void
- distribute_local_to_global(const InVector & local_vector,
+ distribute_local_to_global(const InVector &local_vector,
const std::vector<size_type> &local_dof_indices,
- OutVector & global_vector) const;
+ OutVector &global_vector) const;
/**
* This function takes a vector of local contributions (@p local_vector)
*/
template <typename VectorType>
void
- distribute_local_to_global(const Vector<number> & local_vector,
+ distribute_local_to_global(const Vector<number> &local_vector,
const std::vector<size_type> &local_dof_indices,
- VectorType & global_vector,
- const FullMatrix<number> & local_matrix) const;
+ VectorType &global_vector,
+ const FullMatrix<number> &local_matrix) const;
/**
* Same as the previous function, except that it uses two (possibly) different
template <typename VectorType>
void
distribute_local_to_global(
- const Vector<number> & local_vector,
+ const Vector<number> &local_vector,
const std::vector<size_type> &local_dof_indices_row,
const std::vector<size_type> &local_dof_indices_col,
- VectorType & global_vector,
- const FullMatrix<number> & local_matrix,
+ VectorType &global_vector,
+ const FullMatrix<number> &local_matrix,
bool diagonal = false) const;
/**
void
distribute_local_to_global(const size_type index,
const number value,
- VectorType & global_vector) const;
+ VectorType &global_vector) const;
/**
* This function takes a pointer to a vector of local contributions (@p
distribute_local_to_global(ForwardIteratorVec local_vector_begin,
ForwardIteratorVec local_vector_end,
ForwardIteratorInd local_indices_begin,
- VectorType & global_vector) const;
+ VectorType &global_vector) const;
/**
* This function takes a matrix of local contributions (@p local_matrix)
*/
template <typename MatrixType>
void
- distribute_local_to_global(const FullMatrix<number> & local_matrix,
+ distribute_local_to_global(const FullMatrix<number> &local_matrix,
const std::vector<size_type> &local_dof_indices,
- MatrixType & global_matrix) const;
+ MatrixType &global_matrix) const;
/**
* This function does almost the same as the function above but can treat
*/
template <typename MatrixType>
void
- distribute_local_to_global(const FullMatrix<number> & local_matrix,
+ distribute_local_to_global(const FullMatrix<number> &local_matrix,
const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- MatrixType & global_matrix) const;
+ MatrixType &global_matrix) const;
/**
* This function does almost the same as the function above for general
*/
template <typename MatrixType>
void
- distribute_local_to_global(const FullMatrix<number> & local_matrix,
+ distribute_local_to_global(const FullMatrix<number> &local_matrix,
const std::vector<size_type> &row_indices,
const AffineConstraints &column_affine_constraints,
const std::vector<size_type> &column_indices,
- MatrixType & global_matrix) const;
+ MatrixType &global_matrix) const;
/**
* This function simultaneously writes elements into matrix and vector,
*/
template <typename MatrixType, typename VectorType>
void
- distribute_local_to_global(const FullMatrix<number> & local_matrix,
- const Vector<number> & local_vector,
+ distribute_local_to_global(const FullMatrix<number> &local_matrix,
+ const Vector<number> &local_vector,
const std::vector<size_type> &local_dof_indices,
- MatrixType & global_matrix,
- VectorType & global_vector,
+ MatrixType &global_matrix,
+ VectorType &global_vector,
bool use_inhomogeneities_for_rhs = false) const;
/**
void
add_entries_local_to_global(
const std::vector<size_type> &local_dof_indices,
- SparsityPatternBase & sparsity_pattern,
+ SparsityPatternBase &sparsity_pattern,
const bool keep_constrained_entries = true,
- const Table<2, bool> & dof_mask = Table<2, bool>()) const;
+ const Table<2, bool> &dof_mask = Table<2, bool>()) const;
/**
* Similar to the other function, but for non-quadratic sparsity patterns.
add_entries_local_to_global(
const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- SparsityPatternBase & sparsity_pattern,
+ SparsityPatternBase &sparsity_pattern,
const bool keep_constrained_entries = true,
- const Table<2, bool> & dof_mask = Table<2, bool>()) const;
+ const Table<2, bool> &dof_mask = Table<2, bool>()) const;
/**
* Similar to the other function, but for non-quadratic sparsity patterns, and
*/
void
add_entries_local_to_global(
- const std::vector<size_type> & row_indices,
+ const std::vector<size_type> &row_indices,
const AffineConstraints<number> &col_constraints,
- const std::vector<size_type> & col_indices,
- SparsityPatternBase & sparsity_pattern,
+ const std::vector<size_type> &col_indices,
+ SparsityPatternBase &sparsity_pattern,
const bool keep_constrained_entries = true,
- const Table<2, bool> & dof_mask = Table<2, bool>()) const;
+ const Table<2, bool> &dof_mask = Table<2, bool>()) const;
/**
* This function imports values from a global vector (@p global_vector) by
typename ForwardIteratorInd,
typename VectorType>
void
- get_dof_values(const VectorType & global_vector,
+ get_dof_values(const VectorType &global_vector,
ForwardIteratorInd local_indices_begin,
ForwardIteratorVec local_vector_begin,
ForwardIteratorVec local_vector_end) const;
*/
bool
is_consistent_in_parallel(const std::vector<IndexSet> &locally_owned_dofs,
- const IndexSet & locally_active_dofs,
+ const IndexSet &locally_active_dofs,
const MPI_Comm mpi_communicator,
const bool verbose = false) const;
*/
template <typename MatrixType, typename VectorType>
void
- distribute_local_to_global(const FullMatrix<number> & local_matrix,
- const Vector<number> & local_vector,
+ distribute_local_to_global(const FullMatrix<number> &local_matrix,
+ const Vector<number> &local_vector,
const std::vector<size_type> &local_dof_indices,
- MatrixType & global_matrix,
- VectorType & global_vector,
+ MatrixType &global_matrix,
+ VectorType &global_vector,
const bool use_inhomogeneities_for_rhs,
const std::integral_constant<bool, false>) const;
*/
template <typename MatrixType, typename VectorType>
void
- distribute_local_to_global(const FullMatrix<number> & local_matrix,
- const Vector<number> & local_vector,
+ distribute_local_to_global(const FullMatrix<number> &local_matrix,
+ const Vector<number> &local_vector,
const std::vector<size_type> &local_dof_indices,
- MatrixType & global_matrix,
- VectorType & global_vector,
+ MatrixType &global_matrix,
+ VectorType &global_vector,
const bool use_inhomogeneities_for_rhs,
const std::integral_constant<bool, true>) const;
*/
void
make_sorted_row_list(const std::vector<size_type> &local_dof_indices,
- std::vector<size_type> & active_dofs) const;
+ std::vector<size_type> &active_dofs) const;
/**
* Internal helper function for distribute_local_to_global function.
resolve_vector_entry(
const size_type i,
const internal::AffineConstraints::GlobalRowsFromLocal<number> &global_rows,
- const Vector<VectorScalar> & local_vector,
- const std::vector<size_type> & local_dof_indices,
+ const Vector<VectorScalar> &local_vector,
+ const std::vector<size_type> &local_dof_indices,
const FullMatrix<MatrixScalar> &local_matrix) const;
};
AffineConstraints<number>::distribute_local_to_global(
const size_type index,
const number value,
- VectorType & global_vector) const
+ VectorType &global_vector) const
{
Assert(lines.empty() || sorted == true, ExcMatrixNotClosed());
ForwardIteratorVec local_vector_begin,
ForwardIteratorVec local_vector_end,
ForwardIteratorInd local_indices_begin,
- VectorType & global_vector) const
+ VectorType &global_vector) const
{
Assert(lines.empty() || sorted == true, ExcMatrixNotClosed());
for (; local_vector_begin != local_vector_end;
template <class InVector, class OutVector>
inline void
AffineConstraints<number>::distribute_local_to_global(
- const InVector & local_vector,
+ const InVector &local_vector,
const std::vector<size_type> &local_dof_indices,
- OutVector & global_vector) const
+ OutVector &global_vector) const
{
Assert(local_vector.size() == local_dof_indices.size(),
ExcDimensionMismatch(local_vector.size(), local_dof_indices.size()));
typename VectorType>
inline void
AffineConstraints<number>::get_dof_values(
- const VectorType & global_vector,
+ const VectorType &global_vector,
ForwardIteratorInd local_indices_begin,
ForwardIteratorVec local_vector_begin,
ForwardIteratorVec local_vector_end) const
template <typename MatrixType>
inline void
AffineConstraints<number>::distribute_local_to_global(
- const FullMatrix<number> & local_matrix,
+ const FullMatrix<number> &local_matrix,
const std::vector<size_type> &local_dof_indices,
- MatrixType & global_matrix) const
+ MatrixType &global_matrix) const
{
// create a dummy and hand on to the function actually implementing this
// feature in the cm.templates.h file.
template <typename MatrixType, typename VectorType>
inline void
AffineConstraints<number>::distribute_local_to_global(
- const FullMatrix<number> & local_matrix,
- const Vector<number> & local_vector,
+ const FullMatrix<number> &local_matrix,
+ const Vector<number> &local_vector,
const std::vector<size_type> &local_dof_indices,
- MatrixType & global_matrix,
- VectorType & global_vector,
+ MatrixType &global_matrix,
+ VectorType &global_vector,
bool use_inhomogeneities_for_rhs) const
{
// enter the internal function with the respective block information set,
template <typename number>
inline AffineConstraints<number>::ConstraintLine::ConstraintLine(
- const size_type & index,
+ const size_type &index,
const typename AffineConstraints<number>::ConstraintLine::Entries &entries,
const number inhomogeneity)
: index(index)
bool
AffineConstraints<number>::is_consistent_in_parallel(
const std::vector<IndexSet> &locally_owned_dofs,
- const IndexSet & locally_active_dofs,
+ const IndexSet &locally_active_dofs,
const MPI_Comm mpi_communicator,
const bool verbose) const
{
std::vector<typename dealii::AffineConstraints<number>::ConstraintLine>
compute_locally_relevant_constraints(
const dealii::AffineConstraints<number> &constraints_in,
- const IndexSet & locally_owned_dofs,
- const IndexSet & locally_relevant_dofs,
+ const IndexSet &locally_owned_dofs,
+ const IndexSet &locally_relevant_dofs,
const MPI_Comm mpi_communicator)
{
// The result vector filled step by step.
void
AffineConstraints<number>::add_selected_constraints(
const AffineConstraints &constraints,
- const IndexSet & filter)
+ const IndexSet &filter)
{
if (constraints.n_constraints() == 0)
return;
template <typename VectorType>
void
AffineConstraints<number>::condense(const VectorType &vec_ghosted,
- VectorType & vec) const
+ VectorType &vec) const
{
Assert(sorted == true, ExcMatrixNotClosed());
template <typename VectorType>
void
AffineConstraints<number>::condense(SparseMatrix<number> &uncondensed,
- VectorType & vec) const
+ VectorType &vec) const
{
// check whether we work on real vectors or we just used a dummy when
// calling the other function above.
template <typename BlockVectorType>
void
AffineConstraints<number>::condense(BlockSparseMatrix<number> &uncondensed,
- BlockVectorType & vec) const
+ BlockVectorType &vec) const
{
// check whether we work on real vectors or we just used a dummy when
// calling the other function above.
template <typename VectorType>
void
set_zero_parallel(const std::vector<size_type> &cm,
- VectorType & vec,
+ VectorType &vec,
size_type shift = 0)
{
Assert(!vec.has_ghost_elements(), ExcInternalError());
template <typename number>
void
- set_zero_parallel(const std::vector<size_type> & cm,
+ set_zero_parallel(const std::vector<size_type> &cm,
LinearAlgebra::distributed::Vector<number> &vec,
size_type shift = 0)
{
template <typename number>
void
set_zero_parallel(
- const std::vector<size_type> & cm,
+ const std::vector<size_type> &cm,
LinearAlgebra::distributed::Vector<number, MemorySpace::Default> &vec,
size_type shift = 0)
{
using ExecutionSpace =
MemorySpace::Default::kokkos_space::execution_space;
ExecutionSpace exec;
- auto * local_values = vec.get_values();
+ auto *local_values = vec.get_values();
Kokkos::parallel_for(
"dealii::set_zero_parallel",
Kokkos::RangePolicy<ExecutionSpace>(exec, 0, n_constraints),
template <typename VectorType>
void
set_zero_in_parallel(const std::vector<size_type> &cm,
- VectorType & vec,
+ VectorType &vec,
std::integral_constant<bool, false>)
{
set_zero_parallel(cm, vec, 0);
template <typename VectorType>
void
set_zero_in_parallel(const std::vector<size_type> &cm,
- VectorType & vec,
+ VectorType &vec,
std::integral_constant<bool, true>)
{
size_type start_shift = 0;
template <typename VectorType>
void
AffineConstraints<number>::distribute_local_to_global(
- const Vector<number> & local_vector,
+ const Vector<number> &local_vector,
const std::vector<size_type> &local_dof_indices,
- VectorType & global_vector,
- const FullMatrix<number> & local_matrix) const
+ VectorType &global_vector,
+ const FullMatrix<number> &local_matrix) const
{
distribute_local_to_global(local_vector,
local_dof_indices,
template <typename VectorType>
void
AffineConstraints<number>::distribute_local_to_global(
- const Vector<number> & local_vector,
+ const Vector<number> &local_vector,
const std::vector<size_type> &local_dof_indices_row,
const std::vector<size_type> &local_dof_indices_col,
- VectorType & global_vector,
- const FullMatrix<number> & local_matrix,
+ VectorType &global_vector,
+ const FullMatrix<number> &local_matrix,
bool diagonal) const
{
Assert(sorted == true, ExcMatrixNotClosed());
import_vector_with_ghost_elements(
const TrilinosWrappers::MPI::Vector &vec,
const IndexSet & /*locally_owned_elements*/,
- const IndexSet & needed_elements,
+ const IndexSet &needed_elements,
TrilinosWrappers::MPI::Vector &output,
const std::integral_constant<bool, false> /*is_block_vector*/)
{
inline void
import_vector_with_ghost_elements(
const PETScWrappers::MPI::Vector &vec,
- const IndexSet & locally_owned_elements,
- const IndexSet & needed_elements,
- PETScWrappers::MPI::Vector & output,
+ const IndexSet &locally_owned_elements,
+ const IndexSet &needed_elements,
+ PETScWrappers::MPI::Vector &output,
const std::integral_constant<bool, false> /*is_block_vector*/)
{
output.reinit(locally_owned_elements,
void
import_vector_with_ghost_elements(
const LinearAlgebra::distributed::Vector<number> &vec,
- const IndexSet & locally_owned_elements,
- const IndexSet & needed_elements,
- LinearAlgebra::distributed::Vector<number> & output,
+ const IndexSet &locally_owned_elements,
+ const IndexSet &needed_elements,
+ LinearAlgebra::distributed::Vector<number> &output,
const std::integral_constant<bool, false> /*is_block_vector*/)
{
// TODO: the in vector might already have all elements. need to find a
void
import_vector_with_ghost_elements(
const VectorType &vec,
- const IndexSet & locally_owned_elements,
- const IndexSet & needed_elements,
- VectorType & output,
+ const IndexSet &locally_owned_elements,
+ const IndexSet &needed_elements,
+ VectorType &output,
const std::integral_constant<bool, true> /*is_block_vector*/)
{
output.reinit(vec.n_blocks());
// on.
template <typename number, typename BlockType>
inline void
- make_block_starts(const BlockType & block_object,
+ make_block_starts(const BlockType &block_object,
GlobalRowsFromLocal<number> &global_rows,
- std::vector<size_type> & block_starts)
+ std::vector<size_type> &block_starts)
{
AssertDimension(block_starts.size(), block_object.n_block_rows() + 1);
// GlobalRowsFromLocal. Used in functions for sparsity patterns.
template <typename BlockType>
inline void
- make_block_starts(const BlockType & block_object,
+ make_block_starts(const BlockType &block_object,
std::vector<size_type> &row_indices,
std::vector<size_type> &block_starts)
{
const size_type i,
const size_type j,
const size_type loc_row,
- const FullMatrix<number> & local_matrix)
+ const FullMatrix<number> &local_matrix)
{
const size_type loc_col = global_cols.local_row(j);
number col_val;
const size_type i,
const size_type column_start,
const size_type column_end,
- const FullMatrix<number> & local_matrix,
- size_type *& col_ptr,
- number *& val_ptr)
+ const FullMatrix<number> &local_matrix,
+ size_type *&col_ptr,
+ number *&val_ptr)
{
if (column_end == column_start)
return;
const size_type i,
const size_type column_start,
const size_type column_end,
- const FullMatrix<number> & local_matrix,
- SparseMatrix<number> * sparse_matrix)
+ const FullMatrix<number> &local_matrix,
+ SparseMatrix<number> *sparse_matrix)
{
if (column_end == column_start)
return;
const size_type i,
const size_type column_start,
const size_type column_end,
- const Table<2, bool> & dof_mask,
- std::vector<size_type>::iterator & col_ptr)
+ const Table<2, bool> &dof_mask,
+ std::vector<size_type>::iterator &col_ptr)
{
if (column_end == column_start)
return;
inline void
set_matrix_diagonals(
const internal::AffineConstraints::GlobalRowsFromLocal<number>
- & global_rows,
- const std::vector<size_type> & local_dof_indices,
- const FullMatrix<number> & local_matrix,
+ &global_rows,
+ const std::vector<size_type> &local_dof_indices,
+ const FullMatrix<number> &local_matrix,
const dealii::AffineConstraints<number> &constraints,
- MatrixType & global_matrix,
- VectorType & global_vector,
+ MatrixType &global_matrix,
+ VectorType &global_vector,
bool use_inhomogeneities_for_rhs)
{
if (global_rows.n_constraints() > 0)
inline void
set_sparsity_diagonals(
const internal::AffineConstraints::GlobalRowsFromLocal<number>
- & global_rows,
+ &global_rows,
const std::vector<size_type> &local_dof_indices,
- const Table<2, bool> & dof_mask,
+ const Table<2, bool> &dof_mask,
const bool keep_constrained_entries,
- ScratchData<number> & scratch_data,
- SparsityPatternBase & sparsity_pattern)
+ ScratchData<number> &scratch_data,
+ SparsityPatternBase &sparsity_pattern)
{
// if we got constraints, need to add the diagonal element and, if the
// user requested so, also the rest of the entries in rows and columns
template <typename number>
void
AffineConstraints<number>::make_sorted_row_list(
- const std::vector<size_type> & local_dof_indices,
+ const std::vector<size_type> &local_dof_indices,
internal::AffineConstraints::GlobalRowsFromLocal<number> &global_rows) const
{
const size_type n_local_dofs = local_dof_indices.size();
inline void
AffineConstraints<number>::make_sorted_row_list(
const std::vector<size_type> &local_dof_indices,
- std::vector<size_type> & active_dofs) const
+ std::vector<size_type> &active_dofs) const
{
const size_type n_local_dofs = local_dof_indices.size();
size_type added_rows = 0;
AffineConstraints<number>::resolve_vector_entry(
const size_type i,
const internal::AffineConstraints::GlobalRowsFromLocal<number> &global_rows,
- const Vector<VectorScalar> & local_vector,
- const std::vector<size_type> & local_dof_indices,
+ const Vector<VectorScalar> &local_vector,
+ const std::vector<size_type> &local_dof_indices,
const FullMatrix<MatrixScalar> &local_matrix) const
{
const size_type loc_row = global_rows.local_row(i);
template <typename MatrixType, typename VectorType>
void
AffineConstraints<number>::distribute_local_to_global(
- const FullMatrix<number> & local_matrix,
- const Vector<number> & local_vector,
+ const FullMatrix<number> &local_matrix,
+ const Vector<number> &local_vector,
const std::vector<size_type> &local_dof_indices,
- MatrixType & global_matrix,
- VectorType & global_vector,
+ MatrixType &global_matrix,
+ VectorType &global_vector,
const bool use_inhomogeneities_for_rhs,
const std::integral_constant<bool, false>) const
{
// the AffineConstraints class (unless we do cast). This involves a little
// bit of logic to determine the type of the matrix value.
std::vector<size_type> &cols = scratch_data->columns;
- std::vector<number> & vals = scratch_data->values;
+ std::vector<number> &vals = scratch_data->values;
// create arrays for writing into the vector as well
std::vector<size_type> &vector_indices = scratch_data->vector_indices;
std::vector<typename VectorType::value_type> &vector_values =
template <typename MatrixType, typename VectorType>
void
AffineConstraints<number>::distribute_local_to_global(
- const FullMatrix<number> & local_matrix,
- const Vector<number> & local_vector,
+ const FullMatrix<number> &local_matrix,
+ const Vector<number> &local_vector,
const std::vector<size_type> &local_dof_indices,
- MatrixType & global_matrix,
- VectorType & global_vector,
+ MatrixType &global_matrix,
+ VectorType &global_vector,
const bool use_inhomogeneities_for_rhs,
const std::integral_constant<bool, true>) const
{
block_starts);
std::vector<size_type> &cols = scratch_data->columns;
- std::vector<number> & vals = scratch_data->values;
+ std::vector<number> &vals = scratch_data->values;
if (use_dealii_matrix == false)
{
cols.resize(n_actual_dofs);
if (use_dealii_matrix == false)
{
size_type *col_ptr = cols.data();
- number * val_ptr = vals.data();
+ number *val_ptr = vals.data();
internal::AffineConstraints::resolve_matrix_row(global_rows,
global_rows,
i,
template <typename MatrixType>
void
AffineConstraints<number>::distribute_local_to_global(
- const FullMatrix<number> & local_matrix,
+ const FullMatrix<number> &local_matrix,
const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- MatrixType & global_matrix) const
+ MatrixType &global_matrix) const
{
distribute_local_to_global(
local_matrix, row_indices, *this, col_indices, global_matrix);
template <typename MatrixType>
void
AffineConstraints<number>::distribute_local_to_global(
- const FullMatrix<number> & local_matrix,
- const std::vector<size_type> & row_indices,
+ const FullMatrix<number> &local_matrix,
+ const std::vector<size_type> &row_indices,
const AffineConstraints<number> &col_constraint_matrix,
- const std::vector<size_type> & col_indices,
- MatrixType & global_matrix) const
+ const std::vector<size_type> &col_indices,
+ MatrixType &global_matrix) const
{
AssertDimension(local_matrix.m(), row_indices.size());
AssertDimension(local_matrix.n(), col_indices.size());
// create arrays for the column data (indices and values) that will then be
// written into the matrix. Shortcut for deal.II sparse matrix
std::vector<size_type> &cols = scratch_data->columns;
- std::vector<number> & vals = scratch_data->values;
+ std::vector<number> &vals = scratch_data->values;
cols.resize(n_actual_col_dofs);
vals.resize(n_actual_col_dofs);
// calculate all the data that will be written into the matrix row.
size_type *col_ptr = cols.data();
- number * val_ptr = vals.data();
+ number *val_ptr = vals.data();
internal::AffineConstraints::resolve_matrix_row(global_rows,
global_cols,
i,
void
AffineConstraints<number>::add_entries_local_to_global(
const std::vector<size_type> &local_dof_indices,
- SparsityPatternBase & sparsity_pattern,
+ SparsityPatternBase &sparsity_pattern,
const bool keep_constrained_entries,
- const Table<2, bool> & dof_mask) const
+ const Table<2, bool> &dof_mask) const
{
Assert(sparsity_pattern.n_rows() == sparsity_pattern.n_cols(),
ExcNotQuadratic());
template <typename number>
void
AffineConstraints<number>::add_entries_local_to_global(
- const std::vector<size_type> & row_indices,
+ const std::vector<size_type> &row_indices,
const AffineConstraints<number> &col_constraints,
- const std::vector<size_type> & col_indices,
- SparsityPatternBase & sparsity_pattern,
+ const std::vector<size_type> &col_indices,
+ SparsityPatternBase &sparsity_pattern,
const bool keep_constrained_entries,
- const Table<2, bool> & dof_mask) const
+ const Table<2, bool> &dof_mask) const
{
const size_type n_local_rows = row_indices.size();
const size_type n_local_cols = col_indices.size();
AffineConstraints<number>::add_entries_local_to_global(
const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- SparsityPatternBase & sparsity_pattern,
+ SparsityPatternBase &sparsity_pattern,
const bool keep_constrained_entries,
- const Table<2, bool> & dof_mask) const
+ const Table<2, bool> &dof_mask) const
{
// Call the function with the same name that takes a column constraint as well
add_entries_local_to_global(row_indices,
extern "C" void
-dnaupd_(int * ido,
- char * bmat,
+dnaupd_(int *ido,
+ char *bmat,
unsigned int *n,
- char * which,
+ char *which,
unsigned int *nev,
const double *tol,
- double * resid,
- int * ncv,
- double * v,
- int * ldv,
- int * iparam,
- int * ipntr,
- double * workd,
- double * workl,
- int * lworkl,
- int * info);
+ double *resid,
+ int *ncv,
+ double *v,
+ int *ldv,
+ int *iparam,
+ int *ipntr,
+ double *workd,
+ double *workl,
+ int *lworkl,
+ int *info);
extern "C" void
-dsaupd_(int * ido,
- char * bmat,
+dsaupd_(int *ido,
+ char *bmat,
unsigned int *n,
- char * which,
+ char *which,
unsigned int *nev,
- double * tol,
- double * resid,
- int * ncv,
- double * v,
- int * ldv,
- int * iparam,
- int * ipntr,
- double * workd,
- double * workl,
- int * lworkl,
- int * info);
+ double *tol,
+ double *resid,
+ int *ncv,
+ double *v,
+ int *ldv,
+ int *iparam,
+ int *ipntr,
+ double *workd,
+ double *workl,
+ int *lworkl,
+ int *info);
extern "C" void
-dneupd_(int * rvec,
- char * howmany,
- int * select,
- double * d,
- double * di,
- double * z,
- int * ldz,
- double * sigmar,
- double * sigmai,
- double * workev,
- char * bmat,
+dneupd_(int *rvec,
+ char *howmany,
+ int *select,
+ double *d,
+ double *di,
+ double *z,
+ int *ldz,
+ double *sigmar,
+ double *sigmai,
+ double *workev,
+ char *bmat,
unsigned int *n,
- char * which,
+ char *which,
unsigned int *nev,
- double * tol,
- double * resid,
- int * ncv,
- double * v,
- int * ldv,
- int * iparam,
- int * ipntr,
- double * workd,
- double * workl,
- int * lworkl,
- int * info);
+ double *tol,
+ double *resid,
+ int *ncv,
+ double *v,
+ int *ldv,
+ int *iparam,
+ int *ipntr,
+ double *workd,
+ double *workl,
+ int *lworkl,
+ int *info);
extern "C" void
-dseupd_(int * rvec,
- char * howmany,
- int * select,
- double * d,
- double * z,
- int * ldz,
- double * sigmar,
- char * bmat,
+dseupd_(int *rvec,
+ char *howmany,
+ int *select,
+ double *d,
+ double *z,
+ int *ldz,
+ double *sigmar,
+ char *bmat,
unsigned int *n,
- char * which,
+ char *which,
unsigned int *nev,
- double * tol,
- double * resid,
- int * ncv,
- double * v,
- int * ldv,
- int * iparam,
- int * ipntr,
- double * workd,
- double * workl,
- int * lworkl,
- int * info);
+ double *tol,
+ double *resid,
+ int *ncv,
+ double *v,
+ int *ldv,
+ int *iparam,
+ int *ipntr,
+ double *workd,
+ double *workl,
+ int *lworkl,
+ int *info);
/**
* Interface for using ARPACK. ARPACK is a collection of Fortran77 subroutines
/**
* Constructor.
*/
- ArpackSolver(SolverControl & control,
+ ArpackSolver(SolverControl &control,
const AdditionalData &data = AdditionalData());
/**
typename MatrixType2,
typename INVERSE>
void
- solve(const MatrixType1 & A,
- const MatrixType2 & B,
- const INVERSE & inverse,
+ solve(const MatrixType1 &A,
+ const MatrixType2 &B,
+ const INVERSE &inverse,
std::vector<std::complex<double>> &eigenvalues,
- std::vector<VectorType> & eigenvectors,
+ std::vector<VectorType> &eigenvectors,
const unsigned int n_eigenvalues = 0);
protected:
}
-inline ArpackSolver::ArpackSolver(SolverControl & control,
+inline ArpackSolver::ArpackSolver(SolverControl &control,
const AdditionalData &data)
: solver_control(control)
, additional_data(data)
typename INVERSE>
inline void
ArpackSolver::solve(const MatrixType1 & /*system_matrix*/,
- const MatrixType2 & mass_matrix,
- const INVERSE & inverse,
+ const MatrixType2 &mass_matrix,
+ const INVERSE &inverse,
std::vector<std::complex<double>> &eigenvalues,
- std::vector<VectorType> & eigenvectors,
+ std::vector<VectorType> &eigenvectors,
const unsigned int n_eigenvalues)
{
// Problem size
dealii::types::blas_int rows,
dealii::types::blas_int cols,
const float alpha,
- const float * A,
+ const float *A,
dealii::types::blas_int lda,
- float * B,
+ float *B,
dealii::types::blas_int ldb)
{
#ifdef DEAL_II_LAPACK_WITH_MKL
dealii::types::blas_int rows,
dealii::types::blas_int cols,
const double alpha,
- const double * A,
+ const double *A,
dealii::types::blas_int lda,
- double * B,
+ double *B,
dealii::types::blas_int ldb)
{
#ifdef DEAL_II_LAPACK_WITH_MKL
const std::complex<float> alpha,
const std::complex<float> *A,
dealii::types::blas_int lda,
- std::complex<float> * B,
+ std::complex<float> *B,
dealii::types::blas_int ldb)
{
#ifdef DEAL_II_LAPACK_WITH_MKL
const std::complex<double> alpha,
const std::complex<double> *A,
dealii::types::blas_int lda,
- std::complex<double> * B,
+ std::complex<double> *B,
dealii::types::blas_int ldb)
{
#ifdef DEAL_II_LAPACK_WITH_MKL
void
apply_with_intermediate_storage(const Function1 &first_op,
const Function2 &loop_op,
- Range & v,
- const Domain & u,
+ Range &v,
+ const Domain &u,
bool add)
{
GrowingVectorMemory<Range> vector_memory;
if (PointerComparison::equal(&v, &u))
{
- const auto first_op = [&op](Range & v,
- const Domain & u,
+ const auto first_op = [&op](Range &v,
+ const Domain &u,
const unsigned int i,
const unsigned int j) {
op.block(i, j).vmult(v.block(i), u.block(j));
};
- const auto loop_op = [&op](Range & v,
- const Domain & u,
+ const auto loop_op = [&op](Range &v,
+ const Domain &u,
const unsigned int i,
const unsigned int j) {
op.block(i, j).vmult_add(v.block(i), u.block(j));
if (PointerComparison::equal(&v, &u))
{
- const auto first_op = [&op](Range & v,
- const Domain & u,
+ const auto first_op = [&op](Range &v,
+ const Domain &u,
const unsigned int i,
const unsigned int j) {
op.block(i, j).vmult(v.block(i), u.block(j));
};
- const auto loop_op = [&op](Range & v,
- const Domain & u,
+ const auto loop_op = [&op](Range &v,
+ const Domain &u,
const unsigned int i,
const unsigned int j) {
op.block(i, j).vmult_add(v.block(i), u.block(j));
if (PointerComparison::equal(&v, &u))
{
- const auto first_op = [&op](Range & v,
- const Domain & u,
+ const auto first_op = [&op](Range &v,
+ const Domain &u,
const unsigned int i,
const unsigned int j) {
op.block(j, i).Tvmult(v.block(i), u.block(j));
};
- const auto loop_op = [&op](Range & v,
- const Domain & u,
+ const auto loop_op = [&op](Range &v,
+ const Domain &u,
const unsigned int i,
const unsigned int j) {
op.block(j, i).Tvmult_add(v.block(i), u.block(j));
if (PointerComparison::equal(&v, &u))
{
- const auto first_op = [&op](Range & v,
- const Domain & u,
+ const auto first_op = [&op](Range &v,
+ const Domain &u,
const unsigned int i,
const unsigned int j) {
op.block(j, i).Tvmult(v.block(i), u.block(j));
};
- const auto loop_op = [&op](Range & v,
- const Domain & u,
+ const auto loop_op = [&op](Range &v,
+ const Domain &u,
const unsigned int i,
const unsigned int j) {
op.block(j, i).Tvmult_add(v.block(i), u.block(j));
return_op.reinit_range_vector = diagonal_inverse.reinit_range_vector;
return_op.reinit_domain_vector = diagonal_inverse.reinit_domain_vector;
- return_op.vmult = [block_operator, diagonal_inverse](Range & v,
+ return_op.vmult = [block_operator, diagonal_inverse](Range &v,
const Range &u) {
const unsigned int m = block_operator.n_block_rows();
Assert(block_operator.n_block_cols() == m,
}
};
- return_op.vmult_add = [block_operator, diagonal_inverse](Range & v,
+ return_op.vmult_add = [block_operator, diagonal_inverse](Range &v,
const Range &u) {
const unsigned int m = block_operator.n_block_rows();
Assert(block_operator.n_block_cols() == m,
return_op.reinit_range_vector = diagonal_inverse.reinit_range_vector;
return_op.reinit_domain_vector = diagonal_inverse.reinit_domain_vector;
- return_op.vmult = [block_operator, diagonal_inverse](Range & v,
+ return_op.vmult = [block_operator, diagonal_inverse](Range &v,
const Range &u) {
const unsigned int m = block_operator.n_block_rows();
Assert(block_operator.n_block_cols() == m,
}
};
- return_op.vmult_add = [block_operator, diagonal_inverse](Range & v,
+ return_op.vmult_add = [block_operator, diagonal_inverse](Range &v,
const Range &u) {
const unsigned int m = block_operator.n_block_rows();
Assert(block_operator.n_block_cols() == m,
template <typename number>
void
set(const std::vector<size_type> &indices,
- const FullMatrix<number> & full_matrix,
+ const FullMatrix<number> &full_matrix,
const bool elide_zero_values = false);
/**
void
set(const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- const FullMatrix<number> & full_matrix,
+ const FullMatrix<number> &full_matrix,
const bool elide_zero_values = false);
/**
void
set(const size_type row,
const std::vector<size_type> &col_indices,
- const std::vector<number> & values,
+ const std::vector<number> &values,
const bool elide_zero_values = false);
/**
set(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number * values,
+ const number *values,
const bool elide_zero_values = false);
/**
template <typename number>
void
add(const std::vector<size_type> &indices,
- const FullMatrix<number> & full_matrix,
+ const FullMatrix<number> &full_matrix,
const bool elide_zero_values = true);
/**
void
add(const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- const FullMatrix<number> & full_matrix,
+ const FullMatrix<number> &full_matrix,
const bool elide_zero_values = true);
/**
void
add(const size_type row,
const std::vector<size_type> &col_indices,
- const std::vector<number> & values,
+ const std::vector<number> &values,
const bool elide_zero_values = true);
/**
add(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number * values,
+ const number *values,
const bool elide_zero_values = true,
const bool col_indices_are_sorted = false);
*/
template <typename BlockVectorType>
value_type
- residual(BlockVectorType & dst,
+ residual(BlockVectorType &dst,
const BlockVectorType &x,
const BlockVectorType &b) const;
inline void
BlockMatrixBase<MatrixType>::set(const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- const FullMatrix<number> & values,
+ const FullMatrix<number> &values,
const bool elide_zero_values)
{
Assert(row_indices.size() == values.m(),
template <typename number>
inline void
BlockMatrixBase<MatrixType>::set(const std::vector<size_type> &indices,
- const FullMatrix<number> & values,
+ const FullMatrix<number> &values,
const bool elide_zero_values)
{
Assert(indices.size() == values.m(),
inline void
BlockMatrixBase<MatrixType>::set(const size_type row,
const std::vector<size_type> &col_indices,
- const std::vector<number> & values,
+ const std::vector<number> &values,
const bool elide_zero_values)
{
Assert(col_indices.size() == values.size(),
BlockMatrixBase<MatrixType>::set(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number * values,
+ const number *values,
const bool elide_zero_values)
{
prepare_set_operation();
inline void
BlockMatrixBase<MatrixType>::add(const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- const FullMatrix<number> & values,
+ const FullMatrix<number> &values,
const bool elide_zero_values)
{
Assert(row_indices.size() == values.m(),
template <typename number>
inline void
BlockMatrixBase<MatrixType>::add(const std::vector<size_type> &indices,
- const FullMatrix<number> & values,
+ const FullMatrix<number> &values,
const bool elide_zero_values)
{
Assert(indices.size() == values.m(),
inline void
BlockMatrixBase<MatrixType>::add(const size_type row,
const std::vector<size_type> &col_indices,
- const std::vector<number> & values,
+ const std::vector<number> &values,
const bool elide_zero_values)
{
Assert(col_indices.size() == values.size(),
BlockMatrixBase<MatrixType>::add(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number * values,
+ const number *values,
const bool elide_zero_values,
const bool col_indices_are_sorted)
{
template <typename MatrixType>
template <typename BlockVectorType>
void
-BlockMatrixBase<MatrixType>::vmult_block_block(BlockVectorType & dst,
+BlockMatrixBase<MatrixType>::vmult_block_block(BlockVectorType &dst,
const BlockVectorType &src) const
{
Assert(dst.n_blocks() == n_block_rows(),
template <typename BlockVectorType, typename VectorType>
void
BlockMatrixBase<MatrixType>::vmult_nonblock_block(
- VectorType & dst,
+ VectorType &dst,
const BlockVectorType &src) const
{
Assert(n_block_rows() == 1, ExcDimensionMismatch(1, n_block_rows()));
template <typename MatrixType>
template <typename BlockVectorType, typename VectorType>
void
-BlockMatrixBase<MatrixType>::vmult_block_nonblock(BlockVectorType & dst,
+BlockMatrixBase<MatrixType>::vmult_block_nonblock(BlockVectorType &dst,
const VectorType &src) const
{
Assert(dst.n_blocks() == n_block_rows(),
template <typename VectorType>
void
BlockMatrixBase<MatrixType>::vmult_nonblock_nonblock(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
Assert(1 == n_block_rows(), ExcDimensionMismatch(1, n_block_rows()));
template <typename MatrixType>
template <typename BlockVectorType>
void
-BlockMatrixBase<MatrixType>::vmult_add(BlockVectorType & dst,
+BlockMatrixBase<MatrixType>::vmult_add(BlockVectorType &dst,
const BlockVectorType &src) const
{
Assert(dst.n_blocks() == n_block_rows(),
template <typename BlockVectorType>
void
BlockMatrixBase<MatrixType>::Tvmult_block_block(
- BlockVectorType & dst,
+ BlockVectorType &dst,
const BlockVectorType &src) const
{
Assert(dst.n_blocks() == n_block_cols(),
template <typename MatrixType>
template <typename BlockVectorType, typename VectorType>
void
-BlockMatrixBase<MatrixType>::Tvmult_block_nonblock(BlockVectorType & dst,
+BlockMatrixBase<MatrixType>::Tvmult_block_nonblock(BlockVectorType &dst,
const VectorType &src) const
{
Assert(dst.n_blocks() == n_block_cols(),
template <typename BlockVectorType, typename VectorType>
void
BlockMatrixBase<MatrixType>::Tvmult_nonblock_block(
- VectorType & dst,
+ VectorType &dst,
const BlockVectorType &src) const
{
Assert(1 == n_block_cols(), ExcDimensionMismatch(1, n_block_cols()));
template <typename VectorType>
void
BlockMatrixBase<MatrixType>::Tvmult_nonblock_nonblock(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
Assert(1 == n_block_cols(), ExcDimensionMismatch(1, n_block_cols()));
template <typename MatrixType>
template <typename BlockVectorType>
void
-BlockMatrixBase<MatrixType>::Tvmult_add(BlockVectorType & dst,
+BlockMatrixBase<MatrixType>::Tvmult_add(BlockVectorType &dst,
const BlockVectorType &src) const
{
Assert(dst.n_blocks() == n_block_cols(),
template <typename MatrixType>
template <typename BlockVectorType>
typename BlockMatrixBase<MatrixType>::value_type
-BlockMatrixBase<MatrixType>::residual(BlockVectorType & dst,
+BlockMatrixBase<MatrixType>::residual(BlockVectorType &dst,
const BlockVectorType &x,
const BlockVectorType &b) const
{
*/
template <typename block_number>
void
- vmult(BlockVector<block_number> & dst,
+ vmult(BlockVector<block_number> &dst,
const BlockVector<block_number> &src) const;
/**
*/
template <typename block_number, typename nonblock_number>
void
- vmult(BlockVector<block_number> & dst,
+ vmult(BlockVector<block_number> &dst,
const Vector<nonblock_number> &src) const;
/**
*/
template <typename block_number, typename nonblock_number>
void
- vmult(Vector<nonblock_number> & dst,
+ vmult(Vector<nonblock_number> &dst,
const BlockVector<block_number> &src) const;
/**
*/
template <typename block_number>
void
- Tvmult(BlockVector<block_number> & dst,
+ Tvmult(BlockVector<block_number> &dst,
const BlockVector<block_number> &src) const;
/**
*/
template <typename block_number, typename nonblock_number>
void
- Tvmult(BlockVector<block_number> & dst,
+ Tvmult(BlockVector<block_number> &dst,
const Vector<nonblock_number> &src) const;
/**
*/
template <typename block_number, typename nonblock_number>
void
- Tvmult(Vector<nonblock_number> & dst,
+ Tvmult(Vector<nonblock_number> &dst,
const BlockVector<block_number> &src) const;
/**
*/
template <typename nonblock_number>
void
- Tvmult(Vector<nonblock_number> & dst,
+ Tvmult(Vector<nonblock_number> &dst,
const Vector<nonblock_number> &src) const;
/** @} */
*/
template <typename BlockVectorType>
void
- precondition_Jacobi(BlockVectorType & dst,
+ precondition_Jacobi(BlockVectorType &dst,
const BlockVectorType &src,
const number omega = 1.) const;
*/
template <typename number2>
void
- precondition_Jacobi(Vector<number2> & dst,
+ precondition_Jacobi(Vector<number2> &dst,
const Vector<number2> &src,
const number omega = 1.) const;
/** @} */
* applied to a large matrix!
*/
void
- print_formatted(std::ostream & out,
+ print_formatted(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const unsigned int width = 0,
- const char * zero_string = " ",
+ const char *zero_string = " ",
const double denominator = 1.) const;
/** @} */
/**
template <typename number>
template <typename block_number>
inline void
-BlockSparseMatrix<number>::vmult(BlockVector<block_number> & dst,
+BlockSparseMatrix<number>::vmult(BlockVector<block_number> &dst,
const BlockVector<block_number> &src) const
{
BaseClass::vmult_block_block(dst, src);
template <typename number>
template <typename block_number, typename nonblock_number>
inline void
-BlockSparseMatrix<number>::vmult(BlockVector<block_number> & dst,
+BlockSparseMatrix<number>::vmult(BlockVector<block_number> &dst,
const Vector<nonblock_number> &src) const
{
BaseClass::vmult_block_nonblock(dst, src);
template <typename number>
template <typename block_number, typename nonblock_number>
inline void
-BlockSparseMatrix<number>::vmult(Vector<nonblock_number> & dst,
+BlockSparseMatrix<number>::vmult(Vector<nonblock_number> &dst,
const BlockVector<block_number> &src) const
{
BaseClass::vmult_nonblock_block(dst, src);
template <typename number>
template <typename nonblock_number>
inline void
-BlockSparseMatrix<number>::vmult(Vector<nonblock_number> & dst,
+BlockSparseMatrix<number>::vmult(Vector<nonblock_number> &dst,
const Vector<nonblock_number> &src) const
{
BaseClass::vmult_nonblock_nonblock(dst, src);
template <typename number>
template <typename block_number>
inline void
-BlockSparseMatrix<number>::Tvmult(BlockVector<block_number> & dst,
+BlockSparseMatrix<number>::Tvmult(BlockVector<block_number> &dst,
const BlockVector<block_number> &src) const
{
BaseClass::Tvmult_block_block(dst, src);
template <typename number>
template <typename block_number, typename nonblock_number>
inline void
-BlockSparseMatrix<number>::Tvmult(BlockVector<block_number> & dst,
+BlockSparseMatrix<number>::Tvmult(BlockVector<block_number> &dst,
const Vector<nonblock_number> &src) const
{
BaseClass::Tvmult_block_nonblock(dst, src);
template <typename number>
template <typename block_number, typename nonblock_number>
inline void
-BlockSparseMatrix<number>::Tvmult(Vector<nonblock_number> & dst,
+BlockSparseMatrix<number>::Tvmult(Vector<nonblock_number> &dst,
const BlockVector<block_number> &src) const
{
BaseClass::Tvmult_nonblock_block(dst, src);
template <typename number>
template <typename nonblock_number>
inline void
-BlockSparseMatrix<number>::Tvmult(Vector<nonblock_number> & dst,
+BlockSparseMatrix<number>::Tvmult(Vector<nonblock_number> &dst,
const Vector<nonblock_number> &src) const
{
BaseClass::Tvmult_nonblock_nonblock(dst, src);
template <typename number>
template <typename BlockVectorType>
inline void
-BlockSparseMatrix<number>::precondition_Jacobi(BlockVectorType & dst,
+BlockSparseMatrix<number>::precondition_Jacobi(BlockVectorType &dst,
const BlockVectorType &src,
const number omega) const
{
template <typename number>
template <typename number2>
inline void
-BlockSparseMatrix<number>::precondition_Jacobi(Vector<number2> & dst,
+BlockSparseMatrix<number>::precondition_Jacobi(Vector<number2> &dst,
const Vector<number2> &src,
const number omega) const
{
template <typename number>
void
-BlockSparseMatrix<number>::print_formatted(std::ostream & out,
+BlockSparseMatrix<number>::print_formatted(std::ostream &out,
const unsigned int precision,
const bool scientific,
const unsigned int width,
- const char * zero_string,
+ const char *zero_string,
const double denominator) const
{
for (size_type r = 0; r < this->n_block_rows(); ++r)
*/
template <typename somenumber>
void
- Tvmult(BlockVector<somenumber> & dst,
+ Tvmult(BlockVector<somenumber> &dst,
const BlockVector<somenumber> &src) const;
/**
*/
template <typename somenumber>
void
- vmult_add(BlockVector<somenumber> & dst,
+ vmult_add(BlockVector<somenumber> &dst,
const BlockVector<somenumber> &src) const;
/**
*/
template <typename somenumber>
void
- Tvmult_add(BlockVector<somenumber> & dst,
+ Tvmult_add(BlockVector<somenumber> &dst,
const BlockVector<somenumber> &src) const;
template <typename Number>
template <typename somenumber>
void
-BlockSparseMatrixEZ<Number>::vmult(BlockVector<somenumber> & dst,
+BlockSparseMatrixEZ<Number>::vmult(BlockVector<somenumber> &dst,
const BlockVector<somenumber> &src) const
{
Assert(dst.n_blocks() == n_block_rows(),
template <typename Number>
template <typename somenumber>
void
-BlockSparseMatrixEZ<Number>::vmult_add(BlockVector<somenumber> & dst,
+BlockSparseMatrixEZ<Number>::vmult_add(BlockVector<somenumber> &dst,
const BlockVector<somenumber> &src) const
{
Assert(dst.n_blocks() == n_block_rows(),
template <typename Number>
template <typename somenumber>
void
-BlockSparseMatrixEZ<Number>::Tvmult(BlockVector<somenumber> & dst,
+BlockSparseMatrixEZ<Number>::Tvmult(BlockVector<somenumber> &dst,
const BlockVector<somenumber> &src) const
{
Assert(dst.n_blocks() == n_block_cols(),
template <typename somenumber>
void
BlockSparseMatrixEZ<Number>::Tvmult_add(
- BlockVector<somenumber> & dst,
+ BlockVector<somenumber> &dst,
const BlockVector<somenumber> &src) const
{
Assert(dst.n_blocks() == n_block_cols(),
* as the overload which takes iterators.
*/
virtual void
- add_row_entries(const size_type & row,
+ add_row_entries(const size_type &row,
const ArrayView<const size_type> &columns,
const bool indices_are_sorted = false) override;
* optimized diagonals, while this is not done for the off-diagonal blocks.
*/
void
- reinit(const BlockIndices & row_indices,
- const BlockIndices & col_indices,
+ reinit(const BlockIndices &row_indices,
+ const BlockIndices &col_indices,
const std::vector<std::vector<unsigned int>> &row_lengths);
template <typename SparsityPatternType>
void
BlockSparsityPatternBase<SparsityPatternType>::add_row_entries(
- const size_type & row,
+ const size_type &row,
const ArrayView<const size_type> &columns,
const bool indices_are_sorted)
{
* Print to a stream.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const bool across = true) const;
public:
template <typename Matrix>
static void
- reinit_range_vector(const Matrix & matrix,
+ reinit_range_vector(const Matrix &matrix,
BlockVector<number> &v,
bool omit_zeroing_entries)
{
template <typename Matrix>
static void
- reinit_domain_vector(const Matrix & matrix,
+ reinit_domain_vector(const Matrix &matrix,
BlockVector<number> &v,
bool omit_zeroing_entries)
{
template <typename Number>
void
-BlockVector<Number>::print(std::ostream & out,
+BlockVector<Number>::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool across) const
internal::is_supported_operation<has_n_blocks_t, T>;
template <typename T>
- constexpr bool is_block_vector = has_block<T> &&has_n_blocks<T>;
+ constexpr bool is_block_vector = has_block<T> && has_n_blocks<T>;
} // namespace internal
/**
* Constructor used internally in this class. The arguments match
* exactly the values of the respective member variables.
*/
- Iterator(BlockVector & parent,
+ Iterator(BlockVector &parent,
const size_type global_index,
const size_type current_block,
const size_type index_within_block,
template <typename OtherNumber>
void
extract_subvector_to(const std::vector<size_type> &indices,
- std::vector<OtherNumber> & values) const;
+ std::vector<OtherNumber> &values) const;
virtual void
extract_subvector_to(const ArrayView<const types::global_dof_index> &indices,
void
add(const size_type n_elements,
const size_type *indices,
- const Number * values);
+ const Number *values);
/**
* $U(0-DIM)+=s$. Addition of <tt>s</tt> to all components. Note that
template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness>::Iterator(
- BlockVector & parent,
+ BlockVector &parent,
const size_type global_index,
const size_type current_block,
const size_type index_within_block,
template <typename BlockVectorType, bool Constness>
- Iterator<BlockVectorType, Constness>::Iterator(BlockVector & parent,
+ Iterator<BlockVectorType, Constness>::Iterator(BlockVector &parent,
const size_type global_index)
: parent(&parent)
, global_index(global_index)
typename BlockVectorBase<VectorType>::value_type
BlockVectorBase<VectorType>::add_and_dot(
const typename BlockVectorBase<VectorType>::value_type a,
- const BlockVectorBase<VectorType> & V,
- const BlockVectorBase<VectorType> & W)
+ const BlockVectorBase<VectorType> &V,
+ const BlockVectorBase<VectorType> &W)
{
AssertDimension(n_blocks(), V.n_blocks());
AssertDimension(n_blocks(), W.n_blocks());
template <typename Number>
inline void
BlockVectorBase<VectorType>::add(const std::vector<size_type> &indices,
- const std::vector<Number> & values)
+ const std::vector<Number> &values)
{
Assert(indices.size() == values.size(),
ExcDimensionMismatch(indices.size(), values.size()));
template <typename Number>
inline void
BlockVectorBase<VectorType>::add(const std::vector<size_type> &indices,
- const Vector<Number> & values)
+ const Vector<Number> &values)
{
Assert(indices.size() == values.size(),
ExcDimensionMismatch(indices.size(), values.size()));
inline void
BlockVectorBase<VectorType>::add(const size_type n_indices,
const size_type *indices,
- const Number * values)
+ const Number *values)
{
for (size_type i = 0; i < n_indices; ++i)
(*this)(indices[i]) += values[i];
inline void
BlockVectorBase<VectorType>::extract_subvector_to(
const std::vector<size_type> &indices,
- std::vector<OtherNumber> & values) const
+ std::vector<OtherNumber> &values) const
{
for (size_type i = 0; i < indices.size(); ++i)
values[i] = operator()(indices[i]);
inline void
BlockVectorBase<VectorType>::extract_subvector_to(
const ArrayView<const types::global_dof_index> &indices,
- ArrayView<value_type> & entries) const
+ ArrayView<value_type> &entries) const
{
AssertDimension(indices.size(), entries.size());
for (unsigned int i = 0; i < indices.size(); ++i)
* not provide for nonzero entries on the entire diagonal.
*/
ChunkSparseMatrix(const ChunkSparsityPattern &sparsity,
- const IdentityMatrix & id);
+ const IdentityMatrix &id);
/**
* Destructor. Free all memory, but do not release the memory of the
add(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool elide_zero_values = true,
const bool col_indices_are_sorted = false);
void
extract_row_copy(const size_type row,
const size_type array_length,
- size_type & row_length,
- size_type * column_indices,
- number * values) const;
+ size_type &row_length,
+ size_type *column_indices,
+ number *values) const;
/** @} */
/**
*/
template <typename somenumber>
somenumber
- residual(Vector<somenumber> & dst,
+ residual(Vector<somenumber> &dst,
const Vector<somenumber> &x,
const Vector<somenumber> &b) const;
*/
template <typename somenumber>
void
- precondition_Jacobi(Vector<somenumber> & dst,
+ precondition_Jacobi(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number omega = 1.) const;
*/
template <typename somenumber>
void
- precondition_SSOR(Vector<somenumber> & dst,
+ precondition_SSOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om = 1.) const;
*/
template <typename somenumber>
void
- precondition_SOR(Vector<somenumber> & dst,
+ precondition_SOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om = 1.) const;
*/
template <typename somenumber>
void
- precondition_TSOR(Vector<somenumber> & dst,
+ precondition_TSOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om = 1.) const;
*/
template <typename somenumber>
void
- PSOR(Vector<somenumber> & v,
+ PSOR(Vector<somenumber> &v,
const std::vector<size_type> &permutation,
const std::vector<size_type> &inverse_permutation,
const number om = 1.) const;
*/
template <typename somenumber>
void
- TPSOR(Vector<somenumber> & v,
+ TPSOR(Vector<somenumber> &v,
const std::vector<size_type> &permutation,
const std::vector<size_type> &inverse_permutation,
const number om = 1.) const;
*/
template <typename somenumber>
void
- SOR_step(Vector<somenumber> & v,
+ SOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number om = 1.) const;
*/
template <typename somenumber>
void
- TSOR_step(Vector<somenumber> & v,
+ TSOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number om = 1.) const;
*/
template <typename somenumber>
void
- SSOR_step(Vector<somenumber> & v,
+ SSOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number om = 1.) const;
/** @} */
* applied to a large matrix!
*/
void
- print_formatted(std::ostream & out,
+ print_formatted(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const unsigned int width = 0,
- const char * zero_string = " ",
+ const char *zero_string = " ",
const double denominator = 1.) const;
/**
ChunkSparseMatrix<number>::add(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool /*elide_zero_values*/,
const bool /*col_indices_are_sorted*/)
{
// the padding elements in chunks that overlap the boundaries of the actual
// matrix -- but since multiplication with a number does not violate the
// invariant of keeping these elements at zero nothing can happen
- number * val_ptr = val.get();
+ number *val_ptr = val.get();
const number *const end_ptr =
val.get() +
cols->sparsity_pattern.n_nonzero_elements() * chunk_size * chunk_size;
// the padding elements in chunks that overlap the boundaries of the actual
// matrix -- but since multiplication with a number does not violate the
// invariant of keeping these elements at zero nothing can happen
- number * val_ptr = val.get();
+ number *val_ptr = val.get();
const number *const end_ptr =
val.get() +
cols->sparsity_pattern.n_nonzero_elements() * chunk_size * chunk_size;
namespace ChunkSparseMatrixIterators
{
template <typename number>
- inline Accessor<number, true>::Accessor(const MatrixType * matrix,
+ inline Accessor<number, true>::Accessor(const MatrixType *matrix,
const unsigned int row)
: ChunkSparsityPatternIterators::Accessor(&matrix->get_sparsity_pattern(),
row)
template <typename number>
- inline Accessor<number, false>::Accessor(MatrixType * matrix,
+ inline Accessor<number, false>::Accessor(MatrixType *matrix,
const unsigned int row)
: ChunkSparsityPatternIterators::Accessor(&matrix->get_sparsity_pattern(),
row)
template <typename number, bool Constness>
- inline Iterator<number, Constness>::Iterator(MatrixType * matrix,
+ inline Iterator<number, Constness>::Iterator(MatrixType *matrix,
const unsigned int row)
: accessor(matrix, row)
{}
vmult_add_on_subrange(const ChunkSparsityPattern &cols,
const unsigned int begin_row,
const unsigned int end_row,
- const number * values,
- const std::size_t * rowstart,
- const size_type * colnums,
- const InVector & src,
- OutVector & dst)
+ const number *values,
+ const std::size_t *rowstart,
+ const size_type *colnums,
+ const InVector &src,
+ OutVector &dst)
{
const size_type m = cols.n_rows();
const size_type n = cols.n_cols();
template <typename number>
ChunkSparseMatrix<number>::ChunkSparseMatrix(const ChunkSparsityPattern &c,
- const IdentityMatrix & id)
+ const IdentityMatrix &id)
: cols(nullptr, "ChunkSparseMatrix")
, val(nullptr)
, max_len(0)
// add everything, including padding elements
const size_type chunk_size = cols->get_chunk_size();
- number * val_ptr = val.get();
- const somenumber * matrix_ptr = matrix.val.get();
+ number *val_ptr = val.get();
+ const somenumber *matrix_ptr = matrix.val.get();
const number *const end_ptr =
val.get() +
cols->sparsity_pattern.n_nonzero_elements() * chunk_size * chunk_size;
void
ChunkSparseMatrix<number>::extract_row_copy(const size_type row,
const size_type array_length,
- size_type & row_length,
- size_type * column_indices,
- number * values) const
+ size_type &row_length,
+ size_type *column_indices,
+ number *values) const
{
(void)array_length;
AssertIndexRange(cols->row_length(row), array_length + 1);
// like in vmult_add, but don't keep an iterator into dst around since we're
// not traversing it sequentially this time
- const number * val_ptr = val.get();
+ const number *val_ptr = val.get();
const size_type *colnum_ptr = cols->sparsity_pattern.colnums.get();
for (size_type chunk_row = 0; chunk_row < n_regular_chunk_rows; ++chunk_row)
const size_type n_regular_chunk_rows =
(rows_have_padding ? n_chunk_rows - 1 : n_chunk_rows);
- const number * val_ptr = val.get();
+ const number *val_ptr = val.get();
const size_type *colnum_ptr = cols->sparsity_pattern.colnums.get();
typename Vector<somenumber>::const_iterator v_ptr = v.begin();
const size_type n_regular_chunk_rows =
(rows_have_padding ? n_chunk_rows - 1 : n_chunk_rows);
- const number * val_ptr = val.get();
+ const number *val_ptr = val.get();
const size_type *colnum_ptr = cols->sparsity_pattern.colnums.get();
typename Vector<somenumber>::const_iterator u_ptr = u.begin();
template <typename number>
template <typename somenumber>
somenumber
-ChunkSparseMatrix<number>::residual(Vector<somenumber> & dst,
+ChunkSparseMatrix<number>::residual(Vector<somenumber> &dst,
const Vector<somenumber> &u,
const Vector<somenumber> &b) const
{
const size_type n_regular_chunk_rows =
(rows_have_padding ? n_chunk_rows - 1 : n_chunk_rows);
- const number * val_ptr = val.get();
+ const number *val_ptr = val.get();
const size_type *colnum_ptr = cols->sparsity_pattern.colnums.get();
typename Vector<somenumber>::iterator dst_ptr = dst.begin();
template <typename number>
template <typename somenumber>
void
-ChunkSparseMatrix<number>::precondition_Jacobi(Vector<somenumber> & dst,
+ChunkSparseMatrix<number>::precondition_Jacobi(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number /*om*/) const
{
template <typename number>
template <typename somenumber>
void
-ChunkSparseMatrix<number>::precondition_SSOR(Vector<somenumber> & dst,
+ChunkSparseMatrix<number>::precondition_SSOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number /*om*/) const
{
template <typename number>
template <typename somenumber>
void
-ChunkSparseMatrix<number>::precondition_SOR(Vector<somenumber> & dst,
+ChunkSparseMatrix<number>::precondition_SOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om) const
{
template <typename number>
template <typename somenumber>
void
-ChunkSparseMatrix<number>::precondition_TSOR(Vector<somenumber> & dst,
+ChunkSparseMatrix<number>::precondition_TSOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om) const
{
template <typename somenumber>
void
ChunkSparseMatrix<number>::PSOR(
- Vector<somenumber> & dst,
+ Vector<somenumber> &dst,
const std::vector<size_type> &permutation,
const std::vector<size_type> &inverse_permutation,
const number /*om*/) const
template <typename somenumber>
void
ChunkSparseMatrix<number>::TPSOR(
- Vector<somenumber> & dst,
+ Vector<somenumber> &dst,
const std::vector<size_type> &permutation,
const std::vector<size_type> &inverse_permutation,
const number /*om*/) const
template <typename number>
template <typename somenumber>
void
-ChunkSparseMatrix<number>::SOR_step(Vector<somenumber> & v,
+ChunkSparseMatrix<number>::SOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number /*om*/) const
{
template <typename number>
template <typename somenumber>
void
-ChunkSparseMatrix<number>::TSOR_step(Vector<somenumber> & v,
+ChunkSparseMatrix<number>::TSOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number /*om*/) const
{
template <typename number>
template <typename somenumber>
void
-ChunkSparseMatrix<number>::SSOR_step(Vector<somenumber> & v,
+ChunkSparseMatrix<number>::SSOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number om) const
{
template <typename number>
void
-ChunkSparseMatrix<number>::print_formatted(std::ostream & out,
+ChunkSparseMatrix<number>::print_formatted(std::ostream &out,
const unsigned int precision,
const bool scientific,
const unsigned int width_,
- const char * zero_string,
+ const char *zero_string,
const double denominator) const
{
AssertThrow(out.fail() == false, ExcIO());
LinearOperator<Range, Domain, Payload>
distribute_constraints_linear_operator(
const AffineConstraints<typename Range::value_type> &constraints,
- const LinearOperator<Range, Domain, Payload> & exemplar)
+ const LinearOperator<Range, Domain, Payload> &exemplar)
{
LinearOperator<Range, Domain, Payload> return_op = exemplar;
v.compress(VectorOperation::add);
};
- return_op.vmult = [vmult_add = return_op.vmult_add](Range & v,
+ return_op.vmult = [vmult_add = return_op.vmult_add](Range &v,
const Domain &u) {
v = 0.;
vmult_add(v, u);
};
- return_op.Tvmult = [Tvmult_add = return_op.Tvmult_add](Domain & v,
+ return_op.Tvmult = [Tvmult_add = return_op.Tvmult_add](Domain &v,
const Range &u) {
v = 0.;
Tvmult_add(v, u);
LinearOperator<Range, Domain, Payload>
project_to_constrained_linear_operator(
const AffineConstraints<typename Range::value_type> &constraints,
- const LinearOperator<Range, Domain, Payload> & exemplar)
+ const LinearOperator<Range, Domain, Payload> &exemplar)
{
LinearOperator<Range, Domain, Payload> return_op = exemplar;
v.compress(VectorOperation::add);
};
- return_op.vmult = [vmult_add = return_op.vmult_add](Range & v,
+ return_op.vmult = [vmult_add = return_op.vmult_add](Range &v,
const Domain &u) {
v = 0.;
vmult_add(v, u);
};
- return_op.Tvmult = [Tvmult_add = return_op.Tvmult_add](Domain & v,
+ return_op.Tvmult = [Tvmult_add = return_op.Tvmult_add](Domain &v,
const Range &u) {
v = 0.;
Tvmult_add(v, u);
LinearOperator<Range, Domain, Payload>
constrained_linear_operator(
const AffineConstraints<typename Range::value_type> &constraints,
- const LinearOperator<Range, Domain, Payload> & linop)
+ const LinearOperator<Range, Domain, Payload> &linop)
{
const auto C = distribute_constraints_linear_operator(constraints, linop);
const auto Ct = transpose_operator(C);
PackagedOperation<Range>
constrained_right_hand_side(
const AffineConstraints<typename Range::value_type> &constraints,
- const LinearOperator<Range, Domain, Payload> & linop,
- const Range & right_hand_side)
+ const LinearOperator<Range, Domain, Payload> &linop,
+ const Range &right_hand_side)
{
PackagedOperation<Range> return_comp;
template <typename Number, template <typename> class Binop>
__global__ void
masked_vector_bin_op(const unsigned int *mask,
- Number * v1,
- const Number * v2,
+ Number *v1,
+ const Number *v2,
const size_type N);
*/
template <typename Number, typename Operation>
__global__ void
- double_vector_reduction(Number * result,
- const Number * v1,
- const Number * v2,
+ double_vector_reduction(Number *result,
+ const Number *v1,
+ const Number *v2,
const size_type N);
*/
template <typename Number>
__global__ void
- add_aV(Number * val,
+ add_aV(Number *val,
const Number a,
- const Number * V_val,
+ const Number *V_val,
const size_type N);
*/
template <typename Number>
__global__ void
- add_aVbW(Number * val,
+ add_aVbW(Number *val,
const Number a,
- const Number * V_val,
+ const Number *V_val,
const Number b,
- const Number * W_val,
+ const Number *W_val,
const size_type N);
template <typename Number>
__global__ void
sadd(const Number s,
- Number * val,
+ Number *val,
const Number a,
- const Number * V_val,
+ const Number *V_val,
const size_type N);
template <typename Number>
__global__ void
sadd(const Number s,
- Number * val,
+ Number *val,
const Number a,
- const Number * V_val,
+ const Number *V_val,
const Number b,
- const Number * W_val,
+ const Number *W_val,
const size_type N);
*/
template <typename Number>
__global__ void
- equ(Number * val,
+ equ(Number *val,
const Number a,
- const Number * V_val,
+ const Number *V_val,
const Number b,
- const Number * W_val,
+ const Number *W_val,
const size_type N);
*/
template <typename Number>
__global__ void
- add_and_dot(Number * res,
- Number * v1,
- const Number * v2,
- const Number * v3,
+ add_and_dot(Number *res,
+ Number *v1,
+ const Number *v2,
+ const Number *v3,
const Number a,
const size_type N);
template <typename Number, typename IndexType>
__global__ void
set_permutated(const IndexType *indices,
- Number * val,
- const Number * v,
+ Number *val,
+ const Number *v,
const IndexType N);
*/
template <typename Number, typename IndexType>
__global__ void
- gather(Number * val,
+ gather(Number *val,
const IndexType *indices,
- const Number * v,
+ const Number *v,
const IndexType N);
template <typename Number>
__global__ void
add_permutated(const size_type *indices,
- Number * val,
- const Number * v,
+ Number *val,
+ const Number *v,
const size_type N);
} // namespace kernel
} // namespace CUDAWrappers
template <typename Number, template <typename> class Binop>
__global__ void
masked_vector_bin_op(const unsigned int *mask,
- Number * v1,
- const Number * v2,
+ Number *v1,
+ const Number *v2,
const size_type N)
{
const size_type idx_base =
template <typename Number, typename Operation>
__device__ void
- reduce(Number * result,
+ reduce(Number *result,
volatile Number *result_buffer,
const size_type local_idx,
const size_type /*global_idx*/,
template <typename Number, typename Operation>
__global__ void
- double_vector_reduction(Number * result,
- const Number * v1,
- const Number * v2,
+ double_vector_reduction(Number *result,
+ const Number *v1,
+ const Number *v2,
const size_type N)
{
__shared__ Number result_buffer[block_size];
template <typename Number>
__global__ void
- add_aV(Number * val,
+ add_aV(Number *val,
const Number a,
- const Number * V_val,
+ const Number *V_val,
const size_type N)
{
const size_type idx_base =
template <typename Number>
__global__ void
- add_aVbW(Number * val,
+ add_aVbW(Number *val,
const Number a,
- const Number * V_val,
+ const Number *V_val,
const Number b,
- const Number * W_val,
+ const Number *W_val,
const size_type N)
{
const size_type idx_base =
template <typename Number>
__global__ void
sadd(const Number s,
- Number * val,
+ Number *val,
const Number a,
- const Number * V_val,
+ const Number *V_val,
const size_type N)
{
const size_type idx_base =
template <typename Number>
__global__ void
sadd(const Number s,
- Number * val,
+ Number *val,
const Number a,
- const Number * V_val,
+ const Number *V_val,
const Number b,
- const Number * W_val,
+ const Number *W_val,
const size_type N)
{
const size_type idx_base =
template <typename Number>
__global__ void
- equ(Number * val,
+ equ(Number *val,
const Number a,
- const Number * V_val,
+ const Number *V_val,
const Number b,
- const Number * W_val,
+ const Number *W_val,
const size_type N)
{
const size_type idx_base =
template <typename Number>
__global__ void
- add_and_dot(Number * res,
- Number * v1,
- const Number * v2,
- const Number * v3,
+ add_and_dot(Number *res,
+ Number *v1,
+ const Number *v2,
+ const Number *v3,
const Number a,
const size_type N)
{
template <typename Number, typename IndexType>
__global__ void
set_permutated(const IndexType *indices,
- Number * val,
- const Number * v,
+ Number *val,
+ const Number *v,
const IndexType N)
{
const size_type idx_base =
template <typename Number, typename IndexType>
__global__ void
- gather(Number * val,
+ gather(Number *val,
const IndexType *indices,
- const Number * v,
+ const Number *v,
const IndexType N)
{
const IndexType idx_base =
template <typename Number>
__global__ void
add_permutated(const size_type *indices,
- Number * val,
- const Number * v,
+ Number *val,
+ const Number *v,
const size_type N)
{
const size_type idx_base =
*/
void
initialize(const SparseMatrix<Number> &matrix,
- const AdditionalData & additional_data = AdditionalData());
+ const AdditionalData &additional_data = AdditionalData());
/**
* Apply the preconditioner.
*/
void
- vmult(LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ vmult(LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;
/**
* is the same as vmult().
*/
void
- Tvmult(LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ Tvmult(LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;
/**
*/
void
initialize(const SparseMatrix<Number> &matrix,
- const AdditionalData & additional_data = AdditionalData());
+ const AdditionalData &additional_data = AdditionalData());
/**
* Apply the preconditioner.
*/
void
- vmult(LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ vmult(LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;
/**
* Apply the transposed preconditioner. Not yet implemented.
*/
void
- Tvmult(LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ Tvmult(LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;
/**
* Constructor. Takes the solver control object and creates the solver.
*/
SolverDirect(const Utilities::CUDA::Handle &handle,
- SolverControl & cn,
- const AdditionalData & data = AdditionalData());
+ SolverControl &cn,
+ const AdditionalData &data = AdditionalData());
/**
* Destructor.
* Solve the linear system <tt>Ax=b</tt>.
*/
void
- solve(const SparseMatrix<Number> & A,
- LinearAlgebra::CUDAWrappers::Vector<Number> & x,
+ solve(const SparseMatrix<Number> &A,
+ LinearAlgebra::CUDAWrappers::Vector<Number> &x,
const LinearAlgebra::CUDAWrappers::Vector<Number> &b);
/**
* host. The sparse matrix on the host is copied on the @ref GlossDevice "device" and the
* elements are reordered according to the format supported by cuSPARSE.
*/
- SparseMatrix(Utilities::CUDA::Handle & handle,
+ SparseMatrix(Utilities::CUDA::Handle &handle,
const ::dealii::SparseMatrix<Number> &sparse_matrix_host);
/**
* supported by cuSPARSE.
*/
void
- reinit(Utilities::CUDA::Handle & handle,
+ reinit(Utilities::CUDA::Handle &handle,
const ::dealii::SparseMatrix<Number> &sparse_matrix_host);
/** @} */
* applied to a large matrix!
*/
void
- print_formatted(std::ostream & out,
+ print_formatted(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const unsigned int width = 0,
- const char * zero_string = " ",
+ const char *zero_string = " ",
const double denominator = 1.) const;
/** @} */
* being this matrix.
*/
void
- vmult(LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ vmult(LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;
/**
* takes this transposed matrix.
*/
void
- Tvmult(LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ Tvmult(LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;
/**
* with $M$ being this matrix.
*/
void
- vmult_add(LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ vmult_add(LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;
/**
* as vmult_add() but takes the transposed matrix.
*/
void
- Tvmult_add(LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ Tvmult_add(LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;
/**
* Source $x$ and destination $dst$ must not be the same vector.
*/
Number
- residual(LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ residual(LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &x,
const LinearAlgebra::CUDAWrappers::Vector<Number> &b) const;
/** @} */
template <typename Number>
void
- SparseMatrix<Number>::print_formatted(std::ostream & out,
+ SparseMatrix<Number>::print_formatted(std::ostream &out,
const unsigned int precision,
const bool scientific,
const unsigned int width_,
- const char * zero_string,
+ const char *zero_string,
const double denominator) const
{
Assert(column_index_dev != nullptr, ExcNotInitialized());
* Print the vector to the output stream @p out.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 2,
const bool scientific = true,
const bool across = true) const;
add(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool elide_zero_values = true,
const bool col_indices_are_sorted = false);
void
apply_to_subrange(const unsigned int begin_range,
const unsigned int end_range,
- const value_type * src_pointer_to_current_range,
- value_type * dst_pointer_to_current_range) const;
+ const value_type *src_pointer_to_current_range,
+ value_type *dst_pointer_to_current_range) const;
/**
* Initialize vector @p dst to have the same size and partition as
DiagonalMatrix<VectorType>::add(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool,
const bool)
{
{
template <typename VectorType>
void
- assign_and_scale(VectorType & dst,
+ assign_and_scale(VectorType &dst,
const VectorType &src,
const VectorType &diagonal)
{
template <typename Number>
void
assign_and_scale(
- LinearAlgebra::distributed::Vector<Number, MemorySpace::Host> & dst,
+ LinearAlgebra::distributed::Vector<Number, MemorySpace::Host> &dst,
const LinearAlgebra::distributed::Vector<Number, MemorySpace::Host> &src,
const LinearAlgebra::distributed::Vector<Number, MemorySpace::Host>
&diagonal)
template <typename VectorType>
void
-DiagonalMatrix<VectorType>::vmult_add(VectorType & dst,
+DiagonalMatrix<VectorType>::vmult_add(VectorType &dst,
const VectorType &src) const
{
VectorType tmp(src);
template <typename VectorType>
void
-DiagonalMatrix<VectorType>::Tvmult_add(VectorType & dst,
+DiagonalMatrix<VectorType>::Tvmult_add(VectorType &dst,
const VectorType &src) const
{
vmult_add(dst, src);
DiagonalMatrix<VectorType>::apply_to_subrange(
const unsigned int begin_range,
const unsigned int end_range,
- const value_type * src_pointer_to_current_range,
- value_type * dst_pointer_to_current_range) const
+ const value_type *src_pointer_to_current_range,
+ value_type *dst_pointer_to_current_range) const
{
AssertIndexRange(begin_range,
diagonal.locally_owned_elements().n_elements() + 1);
AssertIndexRange(end_range,
diagonal.locally_owned_elements().n_elements() + 1);
- const value_type * diagonal_entry = diagonal.begin() + begin_range;
+ const value_type *diagonal_entry = diagonal.begin() + begin_range;
const unsigned int length = end_range - begin_range;
DEAL_II_OPENMP_SIMD_PRAGMA
const bool indices_are_unique_and_sorted = false);
virtual void
- add_row_entries(const size_type & row,
+ add_row_entries(const size_type &row,
const ArrayView<const size_type> &columns,
const bool indices_are_sorted = false) override;
*/
template <typename SparsityPatternTypeLeft, typename SparsityPatternTypeRight>
void
- compute_mmult_pattern(const SparsityPatternTypeLeft & left,
+ compute_mmult_pattern(const SparsityPatternTypeLeft &left,
const SparsityPatternTypeRight &right);
/**
*/
template <typename SparsityPatternTypeLeft, typename SparsityPatternTypeRight>
void
- compute_Tmmult_pattern(const SparsityPatternTypeLeft & left,
+ compute_Tmmult_pattern(const SparsityPatternTypeLeft &left,
const SparsityPatternTypeRight &right);
/**
/**
* Constructor.
*/
- EigenPower(SolverControl & cn,
+ EigenPower(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
/**
* Constructor.
*/
- EigenInverse(SolverControl & cn,
+ EigenInverse(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
* Inverse method. @p value is the start guess for the eigenvalue and @p x
template <typename VectorType>
-EigenPower<VectorType>::EigenPower(SolverControl & cn,
+EigenPower<VectorType>::EigenPower(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<VectorType>(cn, mem)
, additional_data(data)
{}
LogStream::Prefix prefix("Power method");
typename VectorMemory<VectorType>::Pointer Vy(this->memory);
- VectorType & y = *Vy;
+ VectorType &y = *Vy;
y.reinit(x);
typename VectorMemory<VectorType>::Pointer Vr(this->memory);
- VectorType & r = *Vr;
+ VectorType &r = *Vr;
r.reinit(x);
double length = x.l2_norm();
//---------------------------------------------------------------------------
template <typename VectorType>
-EigenInverse<VectorType>::EigenInverse(SolverControl & cn,
+EigenInverse<VectorType>::EigenInverse(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<VectorType>(cn, mem)
, additional_data(data)
{}
template <typename VectorType>
template <typename MatrixType>
void
-EigenInverse<VectorType>::solve(double & value,
+EigenInverse<VectorType>::solve(double &value,
const MatrixType &A,
- VectorType & x)
+ VectorType &x)
{
LogStream::Prefix prefix("Wielandt");
// Auxiliary vector
typename VectorMemory<VectorType>::Pointer Vy(this->memory);
- VectorType & y = *Vy;
+ VectorType &y = *Vy;
y.reinit(x);
typename VectorMemory<VectorType>::Pointer Vr(this->memory);
- VectorType & r = *Vr;
+ VectorType &r = *Vr;
r.reinit(x);
double length = x.l2_norm();
if (iter == goal)
{
- const auto & relaxation = additional_data.relaxation;
+ const auto &relaxation = additional_data.relaxation;
const double new_shift =
relaxation * (-value) + (1. - relaxation) * current_shift;
*/
template <int dim>
void
- copy_to(Tensor<2, dim> & T,
+ copy_to(Tensor<2, dim> &T,
const size_type src_r_i = 0,
const size_type src_r_j = dim - 1,
const size_type src_c_i = 0,
*/
template <typename MatrixType, typename index_type>
void
- extract_submatrix_from(const MatrixType & matrix,
+ extract_submatrix_from(const MatrixType &matrix,
const std::vector<index_type> &row_index_set,
const std::vector<index_type> &column_index_set);
void
scatter_matrix_to(const std::vector<index_type> &row_index_set,
const std::vector<index_type> &column_index_set,
- MatrixType & matrix) const;
+ MatrixType &matrix) const;
/**
* Fill rectangular block.
*/
template <typename number2>
void
- fill_permutation(const FullMatrix<number2> & src,
+ fill_permutation(const FullMatrix<number2> &src,
const std::vector<size_type> &p_rows,
const std::vector<size_type> &p_cols);
*/
template <typename StreamType>
void
- print(StreamType & s,
+ print(StreamType &s,
const unsigned int width = 5,
const unsigned int precision = 2) const;
* this are considered zero.
*/
void
- print_formatted(std::ostream & out,
+ print_formatted(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const unsigned int width = 0,
- const char * zero_string = " ",
+ const char *zero_string = " ",
const double denominator = 1.,
const double threshold = 0.) const;
add(const size_type row,
const size_type n_cols,
const index_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool elide_zero_values = true,
const bool col_indices_are_sorted = false);
*/
template <typename number2>
void
- mmult(FullMatrix<number2> & C,
+ mmult(FullMatrix<number2> &C,
const FullMatrix<number2> &B,
const bool adding = false) const;
*/
template <typename number2>
void
- Tmmult(FullMatrix<number2> & C,
+ Tmmult(FullMatrix<number2> &C,
const FullMatrix<number2> &B,
const bool adding = false) const;
*/
template <typename number2>
void
- mTmult(FullMatrix<number2> & C,
+ mTmult(FullMatrix<number2> &C,
const FullMatrix<number2> &B,
const bool adding = false) const;
*/
template <typename number2>
void
- TmTmult(FullMatrix<number2> & C,
+ TmTmult(FullMatrix<number2> &C,
const FullMatrix<number2> &B,
const bool adding = false) const;
*/
template <typename number2>
void
- vmult(Vector<number2> & w,
+ vmult(Vector<number2> &w,
const Vector<number2> &v,
const bool adding = false) const;
*/
template <typename number2>
void
- Tvmult(Vector<number2> & w,
+ Tvmult(Vector<number2> &w,
const Vector<number2> &v,
const bool adding = false) const;
*/
template <typename somenumber>
void
- precondition_Jacobi(Vector<somenumber> & dst,
+ precondition_Jacobi(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number omega = 1.) const;
*/
template <typename number2, typename number3>
number
- residual(Vector<number2> & dst,
+ residual(Vector<number2> &dst,
const Vector<number2> &x,
const Vector<number3> &b) const;
template <typename number>
template <int dim>
void
-FullMatrix<number>::copy_to(Tensor<2, dim> & T,
+FullMatrix<number>::copy_to(Tensor<2, dim> &T,
const size_type src_r_i,
const size_type src_r_j,
const size_type src_c_i,
template <typename MatrixType, typename index_type>
inline void
FullMatrix<number>::extract_submatrix_from(
- const MatrixType & matrix,
+ const MatrixType &matrix,
const std::vector<index_type> &row_index_set,
const std::vector<index_type> &column_index_set)
{
FullMatrix<number>::scatter_matrix_to(
const std::vector<index_type> &row_index_set,
const std::vector<index_type> &column_index_set,
- MatrixType & matrix) const
+ MatrixType &matrix) const
{
AssertDimension(row_index_set.size(), this->n_rows());
AssertDimension(column_index_set.size(), this->n_cols());
template <typename number>
template <typename number2>
void
-FullMatrix<number>::vmult_add(Vector<number2> & w,
+FullMatrix<number>::vmult_add(Vector<number2> &w,
const Vector<number2> &v) const
{
vmult(w, v, true);
template <typename number>
template <typename number2>
void
-FullMatrix<number>::Tvmult_add(Vector<number2> & w,
+FullMatrix<number>::Tvmult_add(Vector<number2> &w,
const Vector<number2> &v) const
{
Tvmult(w, v, true);
FullMatrix<number>::add(const size_type row,
const size_type n_cols,
const index_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool,
const bool)
{
template <typename number>
template <typename StreamType>
inline void
-FullMatrix<number>::print(StreamType & s,
+FullMatrix<number>::print(StreamType &s,
const unsigned int w,
const unsigned int p) const
{
template <typename number>
FullMatrix<number>::FullMatrix(const size_type m,
const size_type n,
- const number * entries)
+ const number *entries)
: Table<2, number>(m, n)
{
this->fill(entries);
{
Assert(!this->empty(), ExcEmptyMatrix());
- const number * p = this->values.data();
+ const number *p = this->values.data();
const number *const e = this->values.data() + this->n_elements();
while (p != e)
if (*p++ != number(0.0))
template <typename number>
template <typename number2>
void
-FullMatrix<number>::vmult(Vector<number2> & dst,
+FullMatrix<number>::vmult(Vector<number2> &dst,
const Vector<number2> &src,
const bool adding) const
{
// get access to the data in order to
// avoid copying it when using the ()
// operator
- const number2 * src_ptr = src.begin();
+ const number2 *src_ptr = src.begin();
const size_type size_m = m(), size_n = n();
for (size_type i = 0; i < size_m; ++i)
{
template <typename number>
template <typename number2>
void
-FullMatrix<number>::Tvmult(Vector<number2> & dst,
+FullMatrix<number>::Tvmult(Vector<number2> &dst,
const Vector<number2> &src,
const bool adding) const
{
Assert(&src != &dst, ExcSourceEqualsDestination());
- const number * e = this->values.data();
- number2 * dst_ptr = &dst(0);
+ const number *e = this->values.data();
+ number2 *dst_ptr = &dst(0);
const size_type size_m = m(), size_n = n();
// zero out data if we are not adding
template <typename number>
template <typename number2, typename number3>
number
-FullMatrix<number>::residual(Vector<number2> & dst,
+FullMatrix<number>::residual(Vector<number2> &dst,
const Vector<number2> &src,
const Vector<number3> &right) const
{
template <typename number>
template <typename number2>
void
-FullMatrix<number>::forward(Vector<number2> & dst,
+FullMatrix<number>::forward(Vector<number2> &dst,
const Vector<number2> &src) const
{
Assert(!this->empty(), ExcEmptyMatrix());
template <typename number>
template <typename number2>
void
-FullMatrix<number>::backward(Vector<number2> & dst,
+FullMatrix<number>::backward(Vector<number2> &dst,
const Vector<number2> &src) const
{
Assert(!this->empty(), ExcEmptyMatrix());
template <typename number>
template <typename number2>
void
-FullMatrix<number>::fill_permutation(const FullMatrix<number2> & src,
+FullMatrix<number>::fill_permutation(const FullMatrix<number2> &src,
const std::vector<size_type> &p_rows,
const std::vector<size_type> &p_cols)
{
template <typename number>
template <typename number2>
void
-FullMatrix<number>::mmult(FullMatrix<number2> & dst,
+FullMatrix<number>::mmult(FullMatrix<number2> &dst,
const FullMatrix<number2> &src,
const bool adding) const
{
const types::blas_int m = static_cast<types::blas_int>(src.n());
const types::blas_int n = static_cast<types::blas_int>(this->m());
const types::blas_int k = static_cast<types::blas_int>(this->n());
- const char * notrans = "n";
+ const char *notrans = "n";
const number alpha = 1.;
const number beta = (adding == true) ? 1. : 0.;
template <typename number>
template <typename number2>
void
-FullMatrix<number>::Tmmult(FullMatrix<number2> & dst,
+FullMatrix<number>::Tmmult(FullMatrix<number2> &dst,
const FullMatrix<number2> &src,
const bool adding) const
{
const types::blas_int m = static_cast<types::blas_int>(src.n());
const types::blas_int n = static_cast<types::blas_int>(this->n());
const types::blas_int k = static_cast<types::blas_int>(this->m());
- const char * trans = "t";
- const char * notrans = "n";
+ const char *trans = "t";
+ const char *notrans = "n";
const number alpha = 1.;
const number beta = (adding == true) ? 1. : 0.;
template <typename number>
template <typename number2>
void
-FullMatrix<number>::mTmult(FullMatrix<number2> & dst,
+FullMatrix<number>::mTmult(FullMatrix<number2> &dst,
const FullMatrix<number2> &src,
const bool adding) const
{
const types::blas_int m = static_cast<types::blas_int>(src.m());
const types::blas_int n = static_cast<types::blas_int>(this->m());
const types::blas_int k = static_cast<types::blas_int>(this->n());
- const char * notrans = "n";
- const char * trans = "t";
+ const char *notrans = "n";
+ const char *trans = "t";
const number alpha = 1.;
const number beta = (adding == true) ? 1. : 0.;
template <typename number>
template <typename number2>
void
-FullMatrix<number>::TmTmult(FullMatrix<number2> & dst,
+FullMatrix<number>::TmTmult(FullMatrix<number2> &dst,
const FullMatrix<number2> &src,
const bool adding) const
{
const types::blas_int m = static_cast<types::blas_int>(src.m());
const types::blas_int n = static_cast<types::blas_int>(this->n());
const types::blas_int k = static_cast<types::blas_int>(this->m());
- const char * trans = "t";
+ const char *trans = "t";
const number alpha = 1.;
const number beta = (adding == true) ? 1. : 0.;
number2 sum = 0.;
const size_type n_rows = m();
- const number * val_ptr = this->values.data();
+ const number *val_ptr = this->values.data();
for (size_type row = 0; row < n_rows; ++row)
{
number2 s = 0.;
const number *const val_end_of_row = val_ptr + n_rows;
- const number2 * v_ptr = v.begin();
+ const number2 *v_ptr = v.begin();
while (val_ptr != val_end_of_row)
s += number2(*val_ptr++) * number2(*v_ptr++);
number2 sum = 0.;
const size_type n_rows = m();
const size_type n_cols = n();
- const number * val_ptr = this->values.data();
+ const number *val_ptr = this->values.data();
for (size_type row = 0; row < n_rows; ++row)
{
number2 s = number2(0.);
const number *const val_end_of_row = val_ptr + n_cols;
- const number2 * v_ptr = v.begin();
+ const number2 *v_ptr = v.begin();
while (val_ptr != val_end_of_row)
s += number2(*val_ptr++) * number2(*v_ptr++);
template <typename number>
template <typename somenumber>
void
-FullMatrix<number>::precondition_Jacobi(Vector<somenumber> & dst,
+FullMatrix<number>::precondition_Jacobi(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om) const
{
Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
const std::size_t n = src.size();
- somenumber * dst_ptr = dst.begin();
+ somenumber *dst_ptr = dst.begin();
const somenumber *src_ptr = src.begin();
for (size_type i = 0; i < n; ++i, ++dst_ptr, ++src_ptr)
template <typename number>
void
-FullMatrix<number>::print_formatted(std::ostream & out,
+FullMatrix<number>::print_formatted(std::ostream &out,
const unsigned int precision,
const bool scientific,
const unsigned int width_,
- const char * zero_string,
+ const char *zero_string,
const double denominator,
const double threshold) const
{
*/
void
solve(const SparseMatrix<ValueType> &matrix,
- Vector<ValueType> & solution,
- const Vector<ValueType> & rhs);
+ Vector<ValueType> &solution,
+ const Vector<ValueType> &rhs);
/**
* Access to the object that controls convergence.
*
* @param[in] data The additional data required by the solver.
*/
- SolverCG(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverCG(SolverControl &solver_control,
+ const std::string &exec_type,
const AdditionalData &data = AdditionalData());
/**
*
* @param[in] data The additional data required by the solver.
*/
- SolverCG(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverCG(SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &preconditioner,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
protected:
/**
*
* @param[in] data The additional data required by the solver.
*/
- SolverBicgstab(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverBicgstab(SolverControl &solver_control,
+ const std::string &exec_type,
const AdditionalData &data = AdditionalData());
/**
*
* @param[in] data The additional data required by the solver.
*/
- SolverBicgstab(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverBicgstab(SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &preconditioner,
const AdditionalData &data = AdditionalData());
*
* @param[in] data The additional data required by the solver.
*/
- SolverCGS(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverCGS(SolverControl &solver_control,
+ const std::string &exec_type,
const AdditionalData &data = AdditionalData());
/**
*
* @param[in] data The additional data required by the solver.
*/
- SolverCGS(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverCGS(SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &preconditioner,
const AdditionalData &data = AdditionalData());
*
* @param[in] data The additional data required by the solver.
*/
- SolverFCG(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverFCG(SolverControl &solver_control,
+ const std::string &exec_type,
const AdditionalData &data = AdditionalData());
/**
*
* @param[in] data The additional data required by the solver.
*/
- SolverFCG(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverFCG(SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &preconditioner,
const AdditionalData &data = AdditionalData());
*
* @param[in] data The additional data required by the solver.
*/
- SolverGMRES(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverGMRES(SolverControl &solver_control,
+ const std::string &exec_type,
const AdditionalData &data = AdditionalData());
/**
*
* @param[in] data The additional data required by the solver.
*/
- SolverGMRES(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverGMRES(SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &preconditioner,
const AdditionalData &data = AdditionalData());
*
* @param[in] data The additional data required by the solver.
*/
- SolverIR(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverIR(SolverControl &solver_control,
+ const std::string &exec_type,
const AdditionalData &data = AdditionalData());
/**
*
* @param[in] data The additional data required by the solver.
*/
- SolverIR(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverIR(SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &inner_solver,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
protected:
/**
*/
template <typename number2>
double
- least_squares(BlockVector<number2> & dst,
+ least_squares(BlockVector<number2> &dst,
const BlockVector<number2> &src) const;
/**
template <typename number>
template <typename number2>
double
-Householder<number>::least_squares(Vector<number2> & dst,
+Householder<number>::least_squares(Vector<number2> &dst,
const Vector<number2> &src) const
{
Assert(!storage.empty(), typename FullMatrix<number2>::ExcEmptyMatrix());
template <typename number>
template <typename number2>
double
-Householder<number>::least_squares(BlockVector<number2> & dst,
+Householder<number>::least_squares(BlockVector<number2> &dst,
const BlockVector<number2> &src) const
{
Assert(!storage.empty(), typename FullMatrix<number2>::ExcEmptyMatrix());
*/
BlockVector(
const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
- & partitioners,
+ &partitioners,
const MPI_Comm &comm_sm = MPI_COMM_SELF);
/**
void
reinit(
const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
- & partitioners,
+ &partitioners,
const MPI_Comm &comm_sm = MPI_COMM_SELF);
/**
void
reinit(
const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
- & partitioners,
+ &partitioners,
const bool make_ghosted,
const MPI_Comm &comm_sm = MPI_COMM_SELF);
*/
template <typename OtherNumber>
void
- add(const std::vector<size_type> & indices,
+ add(const std::vector<size_type> &indices,
const ::dealii::Vector<OtherNumber> &values);
/**
*/
template <typename FullMatrixType>
void
- multivector_inner_product(FullMatrixType & matrix,
+ multivector_inner_product(FullMatrixType &matrix,
const BlockVector<Number> &V,
const bool symmetric = false) const;
*/
template <typename FullMatrixType>
Number
- multivector_inner_product_with_metric(const FullMatrixType & matrix,
+ multivector_inner_product_with_metric(const FullMatrixType &matrix,
const BlockVector<Number> &V,
const bool symmetric = false) const;
*/
template <typename FullMatrixType>
void
- mmult(BlockVector<Number> & V,
+ mmult(BlockVector<Number> &V,
const FullMatrixType &matrix,
const Number s = Number(0.),
const Number b = Number(1.)) const;
*/
void
add(const std::vector<size_type> &indices,
- const std::vector<Number> & values);
+ const std::vector<Number> &values);
/**
* Scaling and simple addition of a multiple of a vector, i.e. <tt>*this =
* Print the vector to the output stream @p out.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const bool across = true) const;
template <typename Number>
BlockVector<Number>::BlockVector(
const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
- & partitioners,
+ &partitioners,
const MPI_Comm &comm_sm)
{
reinit(partitioners, comm_sm);
void
BlockVector<Number>::reinit(
const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
- & partitioners,
+ &partitioners,
const MPI_Comm &comm_sm)
{
// update the number of blocks
void
copy_petsc_vector(const PETSC_Number *petsc_start_ptr,
const PETSC_Number *petsc_end_ptr,
- Number * ptr)
+ Number *ptr)
{
std::copy(petsc_start_ptr, petsc_end_ptr, ptr);
}
void
copy_petsc_vector(const std::complex<PETSC_Number> *petsc_start_ptr,
const std::complex<PETSC_Number> *petsc_end_ptr,
- std::complex<Number> * ptr)
+ std::complex<Number> *ptr)
{
std::copy(petsc_start_ptr, petsc_end_ptr, ptr);
}
template <typename Number>
template <typename OtherNumber>
void
- BlockVector<Number>::add(const std::vector<size_type> & indices,
+ BlockVector<Number>::add(const std::vector<size_type> &indices,
const ::dealii::Vector<OtherNumber> &values)
{
for (size_type i = 0; i < indices.size(); ++i)
template <typename Number>
void
BlockVector<Number>::add(const std::vector<size_type> &indices,
- const std::vector<Number> & values)
+ const std::vector<Number> &values)
{
for (size_type i = 0; i < indices.size(); ++i)
(*this)(indices[i]) += values[i];
template <typename Number>
void
- BlockVector<Number>::print(std::ostream & out,
+ BlockVector<Number>::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool across) const
template <typename FullMatrixType>
Number
BlockVector<Number>::multivector_inner_product_with_metric(
- const FullMatrixType & matrix,
+ const FullMatrixType &matrix,
const BlockVector<Number> &V,
const bool symmetric) const
{
template <typename Number>
template <typename FullMatrixType>
void
- BlockVector<Number>::mmult(BlockVector<Number> & V,
+ BlockVector<Number>::mmult(BlockVector<Number> &V,
const FullMatrixType &matrix,
const Number s,
const Number b) const
*/
void
add(const std::vector<size_type> &indices,
- const std::vector<Number> & values);
+ const std::vector<Number> &values);
/**
* Scaling and simple addition of a multiple of a vector, i.e. <tt>*this =
* Print the vector to the output stream @p out.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const bool across = true) const;
*/
template <typename OtherNumber>
void
- add(const std::vector<size_type> & indices,
+ add(const std::vector<size_type> &indices,
const ::dealii::Vector<OtherNumber> &values);
/**
template <typename OtherNumber>
void
add(const size_type n_elements,
- const size_type * indices,
+ const size_type *indices,
const OtherNumber *values);
/**
template <typename OtherNumber>
void
extract_subvector_to(const std::vector<size_type> &indices,
- std::vector<OtherNumber> & values) const;
+ std::vector<OtherNumber> &values) const;
/**
* Extract a range of elements all at once.
inline void
Vector<Number, MemorySpace>::extract_subvector_to(
const std::vector<size_type> &indices,
- std::vector<OtherNumber> & values) const
+ std::vector<OtherNumber> &values) const
{
for (size_type i = 0; i < indices.size(); ++i)
values[i] = operator()(indices[i]);
template <typename OtherNumber>
inline void
Vector<Number, MemorySpace>::add(
- const std::vector<size_type> & indices,
+ const std::vector<size_type> &indices,
const ::dealii::Vector<OtherNumber> &values)
{
AssertDimension(indices.size(), values.size());
template <typename OtherNumber>
inline void
Vector<Number, MemorySpace>::add(const size_type n_elements,
- const size_type * indices,
+ const size_type *indices,
const OtherNumber *values)
{
for (size_type i = 0; i < n_elements; ++i, ++indices, ++values)
#endif
MatrixType> * = nullptr>
static void
- reinit_domain_vector(MatrixType & mat,
+ reinit_domain_vector(MatrixType &mat,
LinearAlgebra::distributed::Vector<Number> &vec,
bool /*omit_zeroing_entries*/)
{
#endif
MatrixType> * = nullptr>
static void
- reinit_domain_vector(MatrixType & mat,
+ reinit_domain_vector(MatrixType &mat,
LinearAlgebra::distributed::Vector<Number> &vec,
bool omit_zeroing_entries)
{
#endif
MatrixType> * = nullptr>
static void
- reinit_range_vector(MatrixType & mat,
+ reinit_range_vector(MatrixType &mat,
LinearAlgebra::distributed::Vector<Number> &vec,
bool /*omit_zeroing_entries*/)
{
#endif
MatrixType> * = nullptr>
static void
- reinit_range_vector(MatrixType & mat,
+ reinit_range_vector(MatrixType &mat,
LinearAlgebra::distributed::Vector<Number> &vec,
bool omit_zeroing_entries)
{
static void
resize_val(const types::global_dof_index new_alloc_size,
- types::global_dof_index & allocated_size,
+ types::global_dof_index &allocated_size,
::dealii::MemorySpace::
MemorySpaceData<Number, ::dealii::MemorySpace::Host> &data,
const MPI_Comm comm_shared)
const ::dealii::LinearAlgebra::ReadWriteVector<Number> &V,
VectorOperation::values operation,
const std::shared_ptr<const ::dealii::Utilities::MPI::Partitioner>
- & communication_pattern,
+ &communication_pattern,
const IndexSet &locally_owned_elem,
::dealii::MemorySpace::MemorySpaceData<Number,
::dealii::MemorySpace::Host>
Number,
::dealii::MemorySpace::Host> &data,
const unsigned int size,
- RealType & max)
+ RealType &max)
{
for (size_type i = 0; i < size; ++i)
max =
static void
resize_val(
const types::global_dof_index new_alloc_size,
- types::global_dof_index & allocated_size,
+ types::global_dof_index &allocated_size,
::dealii::MemorySpace::MemorySpaceData<Number,
::dealii::MemorySpace::Default>
- & data,
+ &data,
const MPI_Comm comm_sm)
{
(void)comm_sm;
const ReadWriteVector<Number> &V,
VectorOperation::values operation,
std::shared_ptr<const Utilities::MPI::Partitioner>
- & communication_pattern,
+ &communication_pattern,
const IndexSet &locally_owned_elem,
::dealii::MemorySpace::MemorySpaceData<Number,
::dealii::MemorySpace::Default>
// including ghost entries. this is not really efficient right now
// because indices are translated twice, once by nth_index_in_set(i)
// and once for operator() of tmp_vector
- const IndexSet & v_stored = V.get_stored_elements();
+ const IndexSet &v_stored = V.get_stored_elements();
const size_type n_elements = v_stored.n_elements();
Kokkos::DefaultHostExecutionSpace host_exec;
Kokkos::View<size_type *, Kokkos::HostSpace> indices(
Number,
::dealii::MemorySpace::Default> &data,
const unsigned int size,
- RealType & result)
+ RealType &result)
{
static_assert(std::is_same_v<Number, RealType>,
"RealType should be the same type as Number");
template <typename Number, typename MemorySpaceType>
void
Vector<Number, MemorySpaceType>::add(const std::vector<size_type> &indices,
- const std::vector<Number> & values)
+ const std::vector<Number> &values)
{
for (std::size_t i = 0; i < indices.size(); ++i)
{
void
Vector<Number, MemorySpaceType>::extract_subvector_to(
const ArrayView<const types::global_dof_index> &indices,
- ArrayView<Number> & elements) const
+ ArrayView<Number> &elements) const
{
AssertDimension(indices.size(), elements.size());
for (unsigned int i = 0; i < indices.size(); ++i)
template <typename Number, typename MemorySpaceType>
void
- Vector<Number, MemorySpaceType>::print(std::ostream & out,
+ Vector<Number, MemorySpaceType>::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool across) const
*/
template <typename number2>
void
- vmult(Vector<number2> & w,
+ vmult(Vector<number2> &w,
const Vector<number2> &v,
const bool adding = false) const;
* Specialization of above function for compatible Vector::value_type.
*/
void
- vmult(Vector<number> & w,
+ vmult(Vector<number> &w,
const Vector<number> &v,
const bool adding = false) const;
*/
template <typename number2>
void
- Tvmult(Vector<number2> & w,
+ Tvmult(Vector<number2> &w,
const Vector<number2> &v,
const bool adding = false) const;
* Specialization of above function for compatible Vector::value_type.
*/
void
- Tvmult(Vector<number> & w,
+ Tvmult(Vector<number> &w,
const Vector<number> &v,
const bool adding = false) const;
* @p This function uses the BLAS function Xgemm.
*/
void
- mmult(LAPACKFullMatrix<number> & C,
+ mmult(LAPACKFullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding = false) const;
* LAPACKFullMatrix.
*/
void
- mmult(FullMatrix<number> & C,
+ mmult(FullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding = false) const;
* @note This function uses the BLAS function Xgemm.
*/
void
- Tmmult(LAPACKFullMatrix<number> & C,
+ Tmmult(LAPACKFullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding = false) const;
* LAPACKFullMatrix.
*/
void
- Tmmult(FullMatrix<number> & C,
+ Tmmult(FullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding = false) const;
* function.
*/
void
- Tmmult(LAPACKFullMatrix<number> & C,
+ Tmmult(LAPACKFullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
- const Vector<number> & V,
+ const Vector<number> &V,
const bool adding = false) const;
/**
* @note This function uses the BLAS function Xgemm.
*/
void
- mTmult(LAPACKFullMatrix<number> & C,
+ mTmult(LAPACKFullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding = false) const;
* LAPACKFullMatrix.
*/
void
- mTmult(FullMatrix<number> & C,
+ mTmult(FullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding = false) const;
* @note This function uses the BLAS function Xgemm.
*/
void
- TmTmult(LAPACKFullMatrix<number> & C,
+ TmTmult(LAPACKFullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding = false) const;
* LAPACKFullMatrix.
*/
void
- TmTmult(FullMatrix<number> & C,
+ TmTmult(FullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding = false) const;
compute_eigenvalues_symmetric(const number lower_bound,
const number upper_bound,
const number abs_accuracy,
- Vector<number> & eigenvalues,
+ Vector<number> &eigenvalues,
FullMatrix<number> &eigenvectors);
/**
*/
void
compute_generalized_eigenvalues_symmetric(
- LAPACKFullMatrix<number> & B,
+ LAPACKFullMatrix<number> &B,
const number lower_bound,
const number upper_bound,
const number abs_accuracy,
- Vector<number> & eigenvalues,
+ Vector<number> &eigenvalues,
std::vector<Vector<number>> &eigenvectors,
const types::blas_int itype = 1);
*/
void
compute_generalized_eigenvalues_symmetric(
- LAPACKFullMatrix<number> & B,
+ LAPACKFullMatrix<number> &B,
std::vector<Vector<number>> &eigenvectors,
const types::blas_int itype = 1);
* function is not allowed.
*/
void
- print_formatted(std::ostream & out,
+ print_formatted(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const unsigned int width = 0,
- const char * zero_string = " ",
+ const char *zero_string = " ",
const double denominator = 1.,
const double threshold = 0.) const;
{
void DEAL_II_FORTRAN_MANGLE(saxpy,
SAXPY)(const dealii::types::blas_int *n,
- const float * sa,
- const float * sx,
+ const float *sa,
+ const float *sx,
const dealii::types::blas_int *incx,
- float * sy,
+ float *sy,
const dealii::types::blas_int *incy);
void DEAL_II_FORTRAN_MANGLE(daxpy,
DAXPY)(const dealii::types::blas_int *n,
- const double * da,
- const double * dx,
+ const double *da,
+ const double *dx,
const dealii::types::blas_int *incx,
- double * dy,
+ double *dy,
const dealii::types::blas_int *incy);
void DEAL_II_FORTRAN_MANGLE(caxpy,
CAXPY)(const dealii::types::blas_int *n,
- const std::complex<float> * ca,
- const std::complex<float> * cx,
+ const std::complex<float> *ca,
+ const std::complex<float> *cx,
const dealii::types::blas_int *incx,
- std::complex<float> * cy,
+ std::complex<float> *cy,
const dealii::types::blas_int *incy);
void DEAL_II_FORTRAN_MANGLE(zaxpy,
ZAXPY)(const dealii::types::blas_int *n,
- const std::complex<double> * za,
- const std::complex<double> * zx,
+ const std::complex<double> *za,
+ const std::complex<double> *zx,
const dealii::types::blas_int *incx,
- std::complex<double> * zy,
+ std::complex<double> *zy,
const dealii::types::blas_int *incy);
void DEAL_II_FORTRAN_MANGLE(sgeev,
- SGEEV)(const char * jobvl,
- const char * jobvr,
+ SGEEV)(const char *jobvl,
+ const char *jobvr,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * wr,
- float * wi,
- float * vl,
+ float *wr,
+ float *wi,
+ float *vl,
const dealii::types::blas_int *ldvl,
- float * vr,
+ float *vr,
const dealii::types::blas_int *ldvr,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dgeev,
- DGEEV)(const char * jobvl,
- const char * jobvr,
+ DGEEV)(const char *jobvl,
+ const char *jobvr,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * wr,
- double * wi,
- double * vl,
+ double *wr,
+ double *wi,
+ double *vl,
const dealii::types::blas_int *ldvl,
- double * vr,
+ double *vr,
const dealii::types::blas_int *ldvr,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cgeev,
- CGEEV)(const char * jobvl,
- const char * jobvr,
+ CGEEV)(const char *jobvl,
+ const char *jobvr,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * w,
- std::complex<float> * vl,
+ std::complex<float> *w,
+ std::complex<float> *vl,
const dealii::types::blas_int *ldvl,
- std::complex<float> * vr,
+ std::complex<float> *vr,
const dealii::types::blas_int *ldvr,
- std::complex<float> * work,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- float * rwork,
- dealii::types::blas_int * info);
+ float *rwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zgeev,
- ZGEEV)(const char * jobvl,
- const char * jobvr,
+ ZGEEV)(const char *jobvl,
+ const char *jobvr,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * w,
- std::complex<double> * vl,
+ std::complex<double> *w,
+ std::complex<double> *vl,
const dealii::types::blas_int *ldvl,
- std::complex<double> * vr,
+ std::complex<double> *vr,
const dealii::types::blas_int *ldvr,
- std::complex<double> * work,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- double * rwork,
- dealii::types::blas_int * info);
+ double *rwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(sgeevx,
- SGEEVX)(const char * balanc,
- const char * jobvl,
- const char * jobvr,
- const char * sense,
+ SGEEVX)(const char *balanc,
+ const char *jobvl,
+ const char *jobvr,
+ const char *sense,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * wr,
- float * wi,
- float * vl,
+ float *wr,
+ float *wi,
+ float *vl,
const dealii::types::blas_int *ldvl,
- float * vr,
+ float *vr,
const dealii::types::blas_int *ldvr,
- dealii::types::blas_int * ilo,
- dealii::types::blas_int * ihi,
- float * scale,
- float * abnrm,
- float * rconde,
- float * rcondv,
- float * work,
+ dealii::types::blas_int *ilo,
+ dealii::types::blas_int *ihi,
+ float *scale,
+ float *abnrm,
+ float *rconde,
+ float *rcondv,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dgeevx,
- DGEEVX)(const char * balanc,
- const char * jobvl,
- const char * jobvr,
- const char * sense,
+ DGEEVX)(const char *balanc,
+ const char *jobvl,
+ const char *jobvr,
+ const char *sense,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * wr,
- double * wi,
- double * vl,
+ double *wr,
+ double *wi,
+ double *vl,
const dealii::types::blas_int *ldvl,
- double * vr,
+ double *vr,
const dealii::types::blas_int *ldvr,
- dealii::types::blas_int * ilo,
- dealii::types::blas_int * ihi,
- double * scale,
- double * abnrm,
- double * rconde,
- double * rcondv,
- double * work,
+ dealii::types::blas_int *ilo,
+ dealii::types::blas_int *ihi,
+ double *scale,
+ double *abnrm,
+ double *rconde,
+ double *rcondv,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cgeevx,
- CGEEVX)(const char * balanc,
- const char * jobvl,
- const char * jobvr,
- const char * sense,
+ CGEEVX)(const char *balanc,
+ const char *jobvl,
+ const char *jobvr,
+ const char *sense,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * w,
- std::complex<float> * vl,
+ std::complex<float> *w,
+ std::complex<float> *vl,
const dealii::types::blas_int *ldvl,
- std::complex<float> * vr,
+ std::complex<float> *vr,
const dealii::types::blas_int *ldvr,
- dealii::types::blas_int * ilo,
- dealii::types::blas_int * ihi,
- float * scale,
- float * abnrm,
- float * rconde,
- float * rcondv,
- std::complex<float> * work,
+ dealii::types::blas_int *ilo,
+ dealii::types::blas_int *ihi,
+ float *scale,
+ float *abnrm,
+ float *rconde,
+ float *rcondv,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- float * rwork,
- dealii::types::blas_int * info);
+ float *rwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zgeevx,
- ZGEEVX)(const char * balanc,
- const char * jobvl,
- const char * jobvr,
- const char * sense,
+ ZGEEVX)(const char *balanc,
+ const char *jobvl,
+ const char *jobvr,
+ const char *sense,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * w,
- std::complex<double> * vl,
+ std::complex<double> *w,
+ std::complex<double> *vl,
const dealii::types::blas_int *ldvl,
- std::complex<double> * vr,
+ std::complex<double> *vr,
const dealii::types::blas_int *ldvr,
- dealii::types::blas_int * ilo,
- dealii::types::blas_int * ihi,
- double * scale,
- double * abnrm,
- double * rconde,
- double * rcondv,
- std::complex<double> * work,
+ dealii::types::blas_int *ilo,
+ dealii::types::blas_int *ihi,
+ double *scale,
+ double *abnrm,
+ double *rconde,
+ double *rcondv,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- double * rwork,
- dealii::types::blas_int * info);
+ double *rwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(sgelsd,
SGELSD)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- float * s,
- const float * rcond,
- dealii::types::blas_int * rank,
- float * work,
+ float *s,
+ const float *rcond,
+ dealii::types::blas_int *rank,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dgelsd,
DGELSD)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- double * s,
- const double * rcond,
- dealii::types::blas_int * rank,
- double * work,
+ double *s,
+ const double *rcond,
+ dealii::types::blas_int *rank,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cgelsd,
CGELSD)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * b,
+ std::complex<float> *b,
const dealii::types::blas_int *ldb,
- float * s,
- const float * rcond,
- dealii::types::blas_int * rank,
- std::complex<float> * work,
+ float *s,
+ const float *rcond,
+ dealii::types::blas_int *rank,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- float * rwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ float *rwork,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zgelsd,
ZGELSD)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * b,
+ std::complex<double> *b,
const dealii::types::blas_int *ldb,
- double * s,
- const double * rcond,
- dealii::types::blas_int * rank,
- std::complex<double> * work,
+ double *s,
+ const double *rcond,
+ dealii::types::blas_int *rank,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- double * rwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ double *rwork,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(sgemm, SGEMM)(const char *transa,
const char *transb,
const float *alpha,
const float *a,
const dealii::types::blas_int *lda,
- const float * b,
+ const float *b,
const dealii::types::blas_int *ldb,
- const float * beta,
- float * c,
+ const float *beta,
+ float *c,
const dealii::types::blas_int *ldc);
void DEAL_II_FORTRAN_MANGLE(dgemm, DGEMM)(const char *transa,
const double *alpha,
const double *a,
const dealii::types::blas_int *lda,
- const double * b,
+ const double *b,
const dealii::types::blas_int *ldb,
- const double * beta,
- double * c,
+ const double *beta,
+ double *c,
const dealii::types::blas_int *ldc);
void DEAL_II_FORTRAN_MANGLE(cgemm, CGEMM)(const char *transa,
const std::complex<float> *alpha,
const std::complex<float> *a,
const dealii::types::blas_int *lda,
- const std::complex<float> * b,
+ const std::complex<float> *b,
const dealii::types::blas_int *ldb,
- const std::complex<float> * beta,
- std::complex<float> * c,
+ const std::complex<float> *beta,
+ std::complex<float> *c,
const dealii::types::blas_int *ldc);
void DEAL_II_FORTRAN_MANGLE(zgemm, ZGEMM)(const char *transa,
const std::complex<double> *alpha,
const std::complex<double> *a,
const dealii::types::blas_int *lda,
- const std::complex<double> * b,
+ const std::complex<double> *b,
const dealii::types::blas_int *ldb,
- const std::complex<double> * beta,
- std::complex<double> * c,
+ const std::complex<double> *beta,
+ std::complex<double> *c,
const dealii::types::blas_int *ldc);
void DEAL_II_FORTRAN_MANGLE(sgemv,
- SGEMV)(const char * trans,
+ SGEMV)(const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const float * alpha,
- const float * a,
+ const float *alpha,
+ const float *a,
const dealii::types::blas_int *lda,
- const float * x,
+ const float *x,
const dealii::types::blas_int *incx,
- const float * beta,
- float * y,
+ const float *beta,
+ float *y,
const dealii::types::blas_int *incy);
void DEAL_II_FORTRAN_MANGLE(dgemv,
- DGEMV)(const char * trans,
+ DGEMV)(const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const double * alpha,
- const double * a,
+ const double *alpha,
+ const double *a,
const dealii::types::blas_int *lda,
- const double * x,
+ const double *x,
const dealii::types::blas_int *incx,
- const double * beta,
- double * y,
+ const double *beta,
+ double *y,
const dealii::types::blas_int *incy);
void DEAL_II_FORTRAN_MANGLE(cgemv,
- CGEMV)(const char * trans,
+ CGEMV)(const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const std::complex<float> * alpha,
- const std::complex<float> * a,
+ const std::complex<float> *alpha,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- const std::complex<float> * x,
+ const std::complex<float> *x,
const dealii::types::blas_int *incx,
- const std::complex<float> * beta,
- std::complex<float> * y,
+ const std::complex<float> *beta,
+ std::complex<float> *y,
const dealii::types::blas_int *incy);
void DEAL_II_FORTRAN_MANGLE(zgemv,
- ZGEMV)(const char * trans,
+ ZGEMV)(const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const std::complex<double> * alpha,
- const std::complex<double> * a,
+ const std::complex<double> *alpha,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- const std::complex<double> * x,
+ const std::complex<double> *x,
const dealii::types::blas_int *incx,
- const std::complex<double> * beta,
- std::complex<double> * y,
+ const std::complex<double> *beta,
+ std::complex<double> *y,
const dealii::types::blas_int *incy);
void DEAL_II_FORTRAN_MANGLE(sgeqrf,
SGEQRF)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * tau,
- float * work,
+ float *tau,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dgeqrf,
DGEQRF)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * tau,
- double * work,
+ double *tau,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cgeqrf,
CGEQRF)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * tau,
- std::complex<float> * work,
+ std::complex<float> *tau,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zgeqrf,
ZGEQRF)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * tau,
- std::complex<double> * work,
+ std::complex<double> *tau,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(sgesdd,
- SGESDD)(const char * jobz,
+ SGESDD)(const char *jobz,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * s,
- float * u,
+ float *s,
+ float *u,
const dealii::types::blas_int *ldu,
- float * vt,
+ float *vt,
const dealii::types::blas_int *ldvt,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dgesdd,
- DGESDD)(const char * jobz,
+ DGESDD)(const char *jobz,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * s,
- double * u,
+ double *s,
+ double *u,
const dealii::types::blas_int *ldu,
- double * vt,
+ double *vt,
const dealii::types::blas_int *ldvt,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cgesdd,
- CGESDD)(const char * jobz,
+ CGESDD)(const char *jobz,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- float * s,
- std::complex<float> * u,
+ float *s,
+ std::complex<float> *u,
const dealii::types::blas_int *ldu,
- std::complex<float> * vt,
+ std::complex<float> *vt,
const dealii::types::blas_int *ldvt,
- std::complex<float> * work,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- float * rwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ float *rwork,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zgesdd,
- ZGESDD)(const char * jobz,
+ ZGESDD)(const char *jobz,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- double * s,
- std::complex<double> * u,
+ double *s,
+ std::complex<double> *u,
const dealii::types::blas_int *ldu,
- std::complex<double> * vt,
+ std::complex<double> *vt,
const dealii::types::blas_int *ldvt,
- std::complex<double> * work,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- double * rwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ double *rwork,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(sgesvd,
- SGESVD)(const char * jobu,
- const char * jobvt,
+ SGESVD)(const char *jobu,
+ const char *jobvt,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * s,
- float * u,
+ float *s,
+ float *u,
const dealii::types::blas_int *ldu,
- float * vt,
+ float *vt,
const dealii::types::blas_int *ldvt,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dgesvd,
- DGESVD)(const char * jobu,
- const char * jobvt,
+ DGESVD)(const char *jobu,
+ const char *jobvt,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * s,
- double * u,
+ double *s,
+ double *u,
const dealii::types::blas_int *ldu,
- double * vt,
+ double *vt,
const dealii::types::blas_int *ldvt,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cgesvd,
- CGESVD)(const char * jobu,
- const char * jobvt,
+ CGESVD)(const char *jobu,
+ const char *jobvt,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- float * s,
- std::complex<float> * u,
+ float *s,
+ std::complex<float> *u,
const dealii::types::blas_int *ldu,
- std::complex<float> * vt,
+ std::complex<float> *vt,
const dealii::types::blas_int *ldvt,
- std::complex<float> * work,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- float * rwork,
- dealii::types::blas_int * info);
+ float *rwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zgesvd,
- ZGESVD)(const char * jobu,
- const char * jobvt,
+ ZGESVD)(const char *jobu,
+ const char *jobvt,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- double * s,
- std::complex<double> * u,
+ double *s,
+ std::complex<double> *u,
const dealii::types::blas_int *ldu,
- std::complex<double> * vt,
+ std::complex<double> *vt,
const dealii::types::blas_int *ldvt,
- std::complex<double> * work,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- double * rwork,
- dealii::types::blas_int * info);
+ double *rwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(sgetrf,
SGETRF)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * ipiv,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *ipiv,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dgetrf,
DGETRF)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * ipiv,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *ipiv,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cgetrf,
CGETRF)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * ipiv,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *ipiv,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zgetrf,
ZGETRF)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * ipiv,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *ipiv,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(sgetri,
SGETRI)(const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dgetri,
DGETRI)(const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cgetri,
CGETRI)(const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- std::complex<float> * work,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zgetri,
ZGETRI)(const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- std::complex<double> * work,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(sgetrs,
- SGETRS)(const char * trans,
+ SGETRS)(const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dgetrs,
- DGETRS)(const char * trans,
+ DGETRS)(const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cgetrs,
- CGETRS)(const char * trans,
+ CGETRS)(const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- std::complex<float> * b,
+ std::complex<float> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zgetrs,
- ZGETRS)(const char * trans,
+ ZGETRS)(const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- std::complex<double> * b,
+ std::complex<double> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
float DEAL_II_FORTRAN_MANGLE(slamch, SLAMCH)(const char *cmach);
double DEAL_II_FORTRAN_MANGLE(dlamch, DLAMCH)(const char *cmach);
float DEAL_II_FORTRAN_MANGLE(slange,
- SLANGE)(const char * norm,
+ SLANGE)(const char *norm,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * work);
+ float *work);
double DEAL_II_FORTRAN_MANGLE(dlange,
- DLANGE)(const char * norm,
+ DLANGE)(const char *norm,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * work);
+ double *work);
float DEAL_II_FORTRAN_MANGLE(clange,
- CLANGE)(const char * norm,
+ CLANGE)(const char *norm,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- float * work);
+ float *work);
double DEAL_II_FORTRAN_MANGLE(zlange,
- ZLANGE)(const char * norm,
+ ZLANGE)(const char *norm,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- double * work);
+ double *work);
float DEAL_II_FORTRAN_MANGLE(slansy,
- SLANSY)(const char * norm,
- const char * uplo,
+ SLANSY)(const char *norm,
+ const char *uplo,
const dealii::types::blas_int *n,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * work);
+ float *work);
double DEAL_II_FORTRAN_MANGLE(dlansy,
- DLANSY)(const char * norm,
- const char * uplo,
+ DLANSY)(const char *norm,
+ const char *uplo,
const dealii::types::blas_int *n,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * work);
+ double *work);
float DEAL_II_FORTRAN_MANGLE(clansy,
- CLANSY)(const char * norm,
- const char * uplo,
+ CLANSY)(const char *norm,
+ const char *uplo,
const dealii::types::blas_int *n,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- float * work);
+ float *work);
double DEAL_II_FORTRAN_MANGLE(zlansy,
- ZLANSY)(const char * norm,
- const char * uplo,
+ ZLANSY)(const char *norm,
+ const char *uplo,
const dealii::types::blas_int *n,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- double * work);
+ double *work);
void DEAL_II_FORTRAN_MANGLE(slascl,
- SLASCL)(const char * type,
+ SLASCL)(const char *type,
const dealii::types::blas_int *kl,
const dealii::types::blas_int *ku,
- const float * cfrom,
- const float * cto,
+ const float *cfrom,
+ const float *cto,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dlascl,
- DLASCL)(const char * type,
+ DLASCL)(const char *type,
const dealii::types::blas_int *kl,
const dealii::types::blas_int *ku,
- const double * cfrom,
- const double * cto,
+ const double *cfrom,
+ const double *cto,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(clascl,
- CLASCL)(const char * type,
+ CLASCL)(const char *type,
const dealii::types::blas_int *kl,
const dealii::types::blas_int *ku,
- const float * cfrom,
- const float * cto,
+ const float *cfrom,
+ const float *cto,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zlascl,
- ZLASCL)(const char * type,
+ ZLASCL)(const char *type,
const dealii::types::blas_int *kl,
const dealii::types::blas_int *ku,
- const double * cfrom,
- const double * cto,
+ const double *cfrom,
+ const double *cto,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(sorgqr,
SORGQR)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- const float * tau,
- float * work,
+ const float *tau,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dorgqr,
DORGQR)(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- const double * tau,
- double * work,
+ const double *tau,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(sormqr,
- SORMQR)(const char * side,
- const char * trans,
+ SORMQR)(const char *side,
+ const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- const float * tau,
- float * c,
+ const float *tau,
+ float *c,
const dealii::types::blas_int *ldc,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dormqr,
- DORMQR)(const char * side,
- const char * trans,
+ DORMQR)(const char *side,
+ const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- const double * tau,
- double * c,
+ const double *tau,
+ double *c,
const dealii::types::blas_int *ldc,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(spocon,
- SPOCON)(const char * uplo,
+ SPOCON)(const char *uplo,
const dealii::types::blas_int *n,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- const float * anorm,
- float * rcond,
- float * work,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ const float *anorm,
+ float *rcond,
+ float *work,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dpocon,
- DPOCON)(const char * uplo,
+ DPOCON)(const char *uplo,
const dealii::types::blas_int *n,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- const double * anorm,
- double * rcond,
- double * work,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ const double *anorm,
+ double *rcond,
+ double *work,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cpocon,
- CPOCON)(const char * uplo,
+ CPOCON)(const char *uplo,
const dealii::types::blas_int *n,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- const float * anorm,
- float * rcond,
- std::complex<float> * work,
- float * rwork,
- dealii::types::blas_int * info);
+ const float *anorm,
+ float *rcond,
+ std::complex<float> *work,
+ float *rwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zpocon,
- ZPOCON)(const char * uplo,
+ ZPOCON)(const char *uplo,
const dealii::types::blas_int *n,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- const double * anorm,
- double * rcond,
- std::complex<double> * work,
- double * rwork,
- dealii::types::blas_int * info);
+ const double *anorm,
+ double *rcond,
+ std::complex<double> *work,
+ double *rwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(spotrf,
- SPOTRF)(const char * uplo,
+ SPOTRF)(const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dpotrf,
- DPOTRF)(const char * uplo,
+ DPOTRF)(const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cpotrf,
- CPOTRF)(const char * uplo,
+ CPOTRF)(const char *uplo,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zpotrf,
- ZPOTRF)(const char * uplo,
+ ZPOTRF)(const char *uplo,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(spotri,
- SPOTRI)(const char * uplo,
+ SPOTRI)(const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dpotri,
- DPOTRI)(const char * uplo,
+ DPOTRI)(const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cpotri,
- CPOTRI)(const char * uplo,
+ CPOTRI)(const char *uplo,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zpotri,
- ZPOTRI)(const char * uplo,
+ ZPOTRI)(const char *uplo,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(spotrs,
- SPOTRS)(const char * uplo,
+ SPOTRS)(const char *uplo,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dpotrs,
- DPOTRS)(const char * uplo,
+ DPOTRS)(const char *uplo,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(cpotrs,
- CPOTRS)(const char * uplo,
+ CPOTRS)(const char *uplo,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * b,
+ std::complex<float> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(zpotrs,
- ZPOTRS)(const char * uplo,
+ ZPOTRS)(const char *uplo,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * b,
+ std::complex<double> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
- void DEAL_II_FORTRAN_MANGLE(sstev, SSTEV)(const char * jobz,
+ void DEAL_II_FORTRAN_MANGLE(sstev, SSTEV)(const char *jobz,
const dealii::types::blas_int *n,
- float * d,
- float * e,
- float * z,
+ float *d,
+ float *e,
+ float *z,
const dealii::types::blas_int *ldz,
- float * work,
+ float *work,
dealii::types::blas_int *info);
- void DEAL_II_FORTRAN_MANGLE(dstev, DSTEV)(const char * jobz,
+ void DEAL_II_FORTRAN_MANGLE(dstev, DSTEV)(const char *jobz,
const dealii::types::blas_int *n,
- double * d,
- double * e,
- double * z,
+ double *d,
+ double *e,
+ double *z,
const dealii::types::blas_int *ldz,
- double * work,
+ double *work,
dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(ssyev,
- SSYEV)(const char * jobz,
- const char * uplo,
+ SSYEV)(const char *jobz,
+ const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * w,
- float * work,
+ float *w,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dsyev,
- DSYEV)(const char * jobz,
- const char * uplo,
+ DSYEV)(const char *jobz,
+ const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * w,
- double * work,
+ double *w,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(ssyevr,
- SSYEVR)(const char * jobz,
- const char * range,
- const char * uplo,
+ SSYEVR)(const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- const float * vl,
- const float * vu,
+ const float *vl,
+ const float *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const float * abstol,
- dealii::types::blas_int * m,
- float * w,
- float * z,
+ const float *abstol,
+ dealii::types::blas_int *m,
+ float *w,
+ float *z,
const dealii::types::blas_int *ldz,
- dealii::types::blas_int * isuppz,
- float * work,
+ dealii::types::blas_int *isuppz,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
+ dealii::types::blas_int *iwork,
const dealii::types::blas_int *liwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dsyevr,
- DSYEVR)(const char * jobz,
- const char * range,
- const char * uplo,
+ DSYEVR)(const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- const double * vl,
- const double * vu,
+ const double *vl,
+ const double *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const double * abstol,
- dealii::types::blas_int * m,
- double * w,
- double * z,
+ const double *abstol,
+ dealii::types::blas_int *m,
+ double *w,
+ double *z,
const dealii::types::blas_int *ldz,
- dealii::types::blas_int * isuppz,
- double * work,
+ dealii::types::blas_int *isuppz,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
+ dealii::types::blas_int *iwork,
const dealii::types::blas_int *liwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(ssyevx,
- SSYEVX)(const char * jobz,
- const char * range,
- const char * uplo,
+ SSYEVX)(const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- const float * vl,
- const float * vu,
+ const float *vl,
+ const float *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const float * abstol,
- dealii::types::blas_int * m,
- float * w,
- float * z,
+ const float *abstol,
+ dealii::types::blas_int *m,
+ float *w,
+ float *z,
const dealii::types::blas_int *ldz,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * ifail,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *ifail,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dsyevx,
- DSYEVX)(const char * jobz,
- const char * range,
- const char * uplo,
+ DSYEVX)(const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- const double * vl,
- const double * vu,
+ const double *vl,
+ const double *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const double * abstol,
- dealii::types::blas_int * m,
- double * w,
- double * z,
+ const double *abstol,
+ dealii::types::blas_int *m,
+ double *w,
+ double *z,
const dealii::types::blas_int *ldz,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * ifail,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *ifail,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(ssygv,
SSYGV)(const dealii::types::blas_int *itype,
- const char * jobz,
- const char * uplo,
+ const char *jobz,
+ const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- float * w,
- float * work,
+ float *w,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dsygv,
DSYGV)(const dealii::types::blas_int *itype,
- const char * jobz,
- const char * uplo,
+ const char *jobz,
+ const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- double * w,
- double * work,
+ double *w,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(ssygvx,
SSYGVX)(const dealii::types::blas_int *itype,
- const char * jobz,
- const char * range,
- const char * uplo,
+ const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- const float * vl,
- const float * vu,
+ const float *vl,
+ const float *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const float * abstol,
- dealii::types::blas_int * m,
- float * w,
- float * z,
+ const float *abstol,
+ dealii::types::blas_int *m,
+ float *w,
+ float *z,
const dealii::types::blas_int *ldz,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * ifail,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *ifail,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dsygvx,
DSYGVX)(const dealii::types::blas_int *itype,
- const char * jobz,
- const char * range,
- const char * uplo,
+ const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- const double * vl,
- const double * vu,
+ const double *vl,
+ const double *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const double * abstol,
- dealii::types::blas_int * m,
- double * w,
- double * z,
+ const double *abstol,
+ dealii::types::blas_int *m,
+ double *w,
+ double *z,
const dealii::types::blas_int *ldz,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * ifail,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *ifail,
+ dealii::types::blas_int *info);
- void DEAL_II_FORTRAN_MANGLE(ssyr, SSYR)(const char * uplo,
+ void DEAL_II_FORTRAN_MANGLE(ssyr, SSYR)(const char *uplo,
const dealii::types::blas_int *n,
- const float * alpha,
- const float * x,
+ const float *alpha,
+ const float *x,
const dealii::types::blas_int *incx,
- float * a,
+ float *a,
const dealii::types::blas_int *lda);
- void DEAL_II_FORTRAN_MANGLE(dsyr, DSYR)(const char * uplo,
+ void DEAL_II_FORTRAN_MANGLE(dsyr, DSYR)(const char *uplo,
const dealii::types::blas_int *n,
- const double * alpha,
- const double * x,
+ const double *alpha,
+ const double *x,
const dealii::types::blas_int *incx,
- double * a,
+ double *a,
const dealii::types::blas_int *lda);
void DEAL_II_FORTRAN_MANGLE(ssyrk, SSYRK)(const char *uplo,
const float *alpha,
const float *a,
const dealii::types::blas_int *lda,
- const float * beta,
- float * c,
+ const float *beta,
+ float *c,
const dealii::types::blas_int *ldc);
void DEAL_II_FORTRAN_MANGLE(dsyrk, DSYRK)(const char *uplo,
const double *alpha,
const double *a,
const dealii::types::blas_int *lda,
- const double * beta,
- double * c,
+ const double *beta,
+ double *c,
const dealii::types::blas_int *ldc);
void DEAL_II_FORTRAN_MANGLE(csyrk, CSYRK)(const char *uplo,
const std::complex<float> *alpha,
const std::complex<float> *a,
const dealii::types::blas_int *lda,
- const std::complex<float> * beta,
- std::complex<float> * c,
+ const std::complex<float> *beta,
+ std::complex<float> *c,
const dealii::types::blas_int *ldc);
void DEAL_II_FORTRAN_MANGLE(zsyrk, ZSYRK)(const char *uplo,
const std::complex<double> *alpha,
const std::complex<double> *a,
const dealii::types::blas_int *lda,
- const std::complex<double> * beta,
- std::complex<double> * c,
+ const std::complex<double> *beta,
+ std::complex<double> *c,
const dealii::types::blas_int *ldc);
void DEAL_II_FORTRAN_MANGLE(strcon,
- STRCON)(const char * norm,
- const char * uplo,
- const char * diag,
+ STRCON)(const char *norm,
+ const char *uplo,
+ const char *diag,
const dealii::types::blas_int *n,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * rcond,
- float * work,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ float *rcond,
+ float *work,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dtrcon,
- DTRCON)(const char * norm,
- const char * uplo,
- const char * diag,
+ DTRCON)(const char *norm,
+ const char *uplo,
+ const char *diag,
const dealii::types::blas_int *n,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * rcond,
- double * work,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info);
+ double *rcond,
+ double *work,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(ctrcon,
- CTRCON)(const char * norm,
- const char * uplo,
- const char * diag,
+ CTRCON)(const char *norm,
+ const char *uplo,
+ const char *diag,
const dealii::types::blas_int *n,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- float * rcond,
- std::complex<float> * work,
- float * rwork,
- dealii::types::blas_int * info);
+ float *rcond,
+ std::complex<float> *work,
+ float *rwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(ztrcon,
- ZTRCON)(const char * norm,
- const char * uplo,
- const char * diag,
+ ZTRCON)(const char *norm,
+ const char *uplo,
+ const char *diag,
const dealii::types::blas_int *n,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- double * rcond,
- std::complex<double> * work,
- double * rwork,
- dealii::types::blas_int * info);
+ double *rcond,
+ std::complex<double> *work,
+ double *rwork,
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(strmv,
- STRMV)(const char * uplo,
- const char * trans,
- const char * diag,
+ STRMV)(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * x,
+ float *x,
const dealii::types::blas_int *incx);
void DEAL_II_FORTRAN_MANGLE(dtrmv,
- DTRMV)(const char * uplo,
- const char * trans,
- const char * diag,
+ DTRMV)(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * x,
+ double *x,
const dealii::types::blas_int *incx);
void DEAL_II_FORTRAN_MANGLE(ctrmv,
- CTRMV)(const char * uplo,
- const char * trans,
- const char * diag,
+ CTRMV)(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * x,
+ std::complex<float> *x,
const dealii::types::blas_int *incx);
void DEAL_II_FORTRAN_MANGLE(ztrmv,
- ZTRMV)(const char * uplo,
- const char * trans,
- const char * diag,
+ ZTRMV)(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * x,
+ std::complex<double> *x,
const dealii::types::blas_int *incx);
void DEAL_II_FORTRAN_MANGLE(strtrs,
- STRTRS)(const char * uplo,
- const char * trans,
- const char * diag,
+ STRTRS)(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(dtrtrs,
- DTRTRS)(const char * uplo,
- const char * trans,
- const char * diag,
+ DTRTRS)(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(ctrtrs,
- CTRTRS)(const char * uplo,
- const char * trans,
- const char * diag,
+ CTRTRS)(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * b,
+ std::complex<float> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
void DEAL_II_FORTRAN_MANGLE(ztrtrs,
- ZTRTRS)(const char * uplo,
- const char * trans,
- const char * diag,
+ ZTRTRS)(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * b,
+ std::complex<double> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info);
+ dealii::types::blas_int *info);
}
#endif
inline void
axpy(const dealii::types::blas_int *n,
- const float * sa,
- const float * sx,
+ const float *sa,
+ const float *sx,
const dealii::types::blas_int *incx,
- float * sy,
+ float *sy,
const dealii::types::blas_int *incy)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
axpy(const dealii::types::blas_int *n,
- const double * da,
- const double * dx,
+ const double *da,
+ const double *dx,
const dealii::types::blas_int *incx,
- double * dy,
+ double *dy,
const dealii::types::blas_int *incy)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
axpy(const dealii::types::blas_int *n,
- const std::complex<float> * ca,
- const std::complex<float> * cx,
+ const std::complex<float> *ca,
+ const std::complex<float> *cx,
const dealii::types::blas_int *incx,
- std::complex<float> * cy,
+ std::complex<float> *cy,
const dealii::types::blas_int *incy)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
axpy(const dealii::types::blas_int *n,
- const std::complex<double> * za,
- const std::complex<double> * zx,
+ const std::complex<double> *za,
+ const std::complex<double> *zx,
const dealii::types::blas_int *incx,
- std::complex<double> * zy,
+ std::complex<double> *zy,
const dealii::types::blas_int *incy)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-geev(const char * jobvl,
- const char * jobvr,
+geev(const char *jobvl,
+ const char *jobvr,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * wr,
- float * wi,
- float * vl,
+ float *wr,
+ float *wi,
+ float *vl,
const dealii::types::blas_int *ldvl,
- float * vr,
+ float *vr,
const dealii::types::blas_int *ldvr,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sgeev, SGEEV)
inline void
-geev(const char * jobvl,
- const char * jobvr,
+geev(const char *jobvl,
+ const char *jobvr,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * wr,
- double * wi,
- double * vl,
+ double *wr,
+ double *wi,
+ double *vl,
const dealii::types::blas_int *ldvl,
- double * vr,
+ double *vr,
const dealii::types::blas_int *ldvr,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dgeev, DGEEV)
inline void
-geev(const char * jobvl,
- const char * jobvr,
+geev(const char *jobvl,
+ const char *jobvr,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * w,
- std::complex<float> * vl,
+ std::complex<float> *w,
+ std::complex<float> *vl,
const dealii::types::blas_int *ldvl,
- std::complex<float> * vr,
+ std::complex<float> *vr,
const dealii::types::blas_int *ldvr,
- std::complex<float> * work,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- float * rwork,
- dealii::types::blas_int * info)
+ float *rwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cgeev, CGEEV)
inline void
-geev(const char * jobvl,
- const char * jobvr,
+geev(const char *jobvl,
+ const char *jobvr,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * w,
- std::complex<double> * vl,
+ std::complex<double> *w,
+ std::complex<double> *vl,
const dealii::types::blas_int *ldvl,
- std::complex<double> * vr,
+ std::complex<double> *vr,
const dealii::types::blas_int *ldvr,
- std::complex<double> * work,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- double * rwork,
- dealii::types::blas_int * info)
+ double *rwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zgeev, ZGEEV)
inline void
-geevx(const char * balanc,
- const char * jobvl,
- const char * jobvr,
- const char * sense,
+geevx(const char *balanc,
+ const char *jobvl,
+ const char *jobvr,
+ const char *sense,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * wr,
- float * wi,
- float * vl,
+ float *wr,
+ float *wi,
+ float *vl,
const dealii::types::blas_int *ldvl,
- float * vr,
+ float *vr,
const dealii::types::blas_int *ldvr,
- dealii::types::blas_int * ilo,
- dealii::types::blas_int * ihi,
- float * scale,
- float * abnrm,
- float * rconde,
- float * rcondv,
- float * work,
+ dealii::types::blas_int *ilo,
+ dealii::types::blas_int *ihi,
+ float *scale,
+ float *abnrm,
+ float *rconde,
+ float *rcondv,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sgeevx, SGEEVX)
inline void
-geevx(const char * balanc,
- const char * jobvl,
- const char * jobvr,
- const char * sense,
+geevx(const char *balanc,
+ const char *jobvl,
+ const char *jobvr,
+ const char *sense,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * wr,
- double * wi,
- double * vl,
+ double *wr,
+ double *wi,
+ double *vl,
const dealii::types::blas_int *ldvl,
- double * vr,
+ double *vr,
const dealii::types::blas_int *ldvr,
- dealii::types::blas_int * ilo,
- dealii::types::blas_int * ihi,
- double * scale,
- double * abnrm,
- double * rconde,
- double * rcondv,
- double * work,
+ dealii::types::blas_int *ilo,
+ dealii::types::blas_int *ihi,
+ double *scale,
+ double *abnrm,
+ double *rconde,
+ double *rcondv,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dgeevx, DGEEVX)
inline void
-geevx(const char * balanc,
- const char * jobvl,
- const char * jobvr,
- const char * sense,
+geevx(const char *balanc,
+ const char *jobvl,
+ const char *jobvr,
+ const char *sense,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * w,
- std::complex<float> * vl,
+ std::complex<float> *w,
+ std::complex<float> *vl,
const dealii::types::blas_int *ldvl,
- std::complex<float> * vr,
+ std::complex<float> *vr,
const dealii::types::blas_int *ldvr,
- dealii::types::blas_int * ilo,
- dealii::types::blas_int * ihi,
- float * scale,
- float * abnrm,
- float * rconde,
- float * rcondv,
- std::complex<float> * work,
+ dealii::types::blas_int *ilo,
+ dealii::types::blas_int *ihi,
+ float *scale,
+ float *abnrm,
+ float *rconde,
+ float *rcondv,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- float * rwork,
- dealii::types::blas_int * info)
+ float *rwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cgeevx, CGEEVX)
inline void
-geevx(const char * balanc,
- const char * jobvl,
- const char * jobvr,
- const char * sense,
+geevx(const char *balanc,
+ const char *jobvl,
+ const char *jobvr,
+ const char *sense,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * w,
- std::complex<double> * vl,
+ std::complex<double> *w,
+ std::complex<double> *vl,
const dealii::types::blas_int *ldvl,
- std::complex<double> * vr,
+ std::complex<double> *vr,
const dealii::types::blas_int *ldvr,
- dealii::types::blas_int * ilo,
- dealii::types::blas_int * ihi,
- double * scale,
- double * abnrm,
- double * rconde,
- double * rcondv,
- std::complex<double> * work,
+ dealii::types::blas_int *ilo,
+ dealii::types::blas_int *ihi,
+ double *scale,
+ double *abnrm,
+ double *rconde,
+ double *rcondv,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- double * rwork,
- dealii::types::blas_int * info)
+ double *rwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zgeevx, ZGEEVX)
gelsd(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- float * s,
- const float * rcond,
- dealii::types::blas_int * rank,
- float * work,
+ float *s,
+ const float *rcond,
+ dealii::types::blas_int *rank,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sgelsd, SGELSD)
gelsd(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- double * s,
- const double * rcond,
- dealii::types::blas_int * rank,
- double * work,
+ double *s,
+ const double *rcond,
+ dealii::types::blas_int *rank,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dgelsd, DGELSD)
gelsd(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * b,
+ std::complex<float> *b,
const dealii::types::blas_int *ldb,
- float * s,
- const float * rcond,
- dealii::types::blas_int * rank,
- std::complex<float> * work,
+ float *s,
+ const float *rcond,
+ dealii::types::blas_int *rank,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- float * rwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ float *rwork,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cgelsd, CGELSD)
gelsd(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * b,
+ std::complex<double> *b,
const dealii::types::blas_int *ldb,
- double * s,
- const double * rcond,
- dealii::types::blas_int * rank,
- std::complex<double> * work,
+ double *s,
+ const double *rcond,
+ dealii::types::blas_int *rank,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- double * rwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ double *rwork,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zgelsd, ZGELSD)
inline void
-gemm(const char * transa,
- const char * transb,
+gemm(const char *transa,
+ const char *transb,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const float * alpha,
- const float * a,
+ const float *alpha,
+ const float *a,
const dealii::types::blas_int *lda,
- const float * b,
+ const float *b,
const dealii::types::blas_int *ldb,
- const float * beta,
- float * c,
+ const float *beta,
+ float *c,
const dealii::types::blas_int *ldc)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-gemm(const char * transa,
- const char * transb,
+gemm(const char *transa,
+ const char *transb,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const double * alpha,
- const double * a,
+ const double *alpha,
+ const double *a,
const dealii::types::blas_int *lda,
- const double * b,
+ const double *b,
const dealii::types::blas_int *ldb,
- const double * beta,
- double * c,
+ const double *beta,
+ double *c,
const dealii::types::blas_int *ldc)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-gemm(const char * transa,
- const char * transb,
+gemm(const char *transa,
+ const char *transb,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const std::complex<float> * alpha,
- const std::complex<float> * a,
+ const std::complex<float> *alpha,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- const std::complex<float> * b,
+ const std::complex<float> *b,
const dealii::types::blas_int *ldb,
- const std::complex<float> * beta,
- std::complex<float> * c,
+ const std::complex<float> *beta,
+ std::complex<float> *c,
const dealii::types::blas_int *ldc)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-gemm(const char * transa,
- const char * transb,
+gemm(const char *transa,
+ const char *transb,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const std::complex<double> * alpha,
- const std::complex<double> * a,
+ const std::complex<double> *alpha,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- const std::complex<double> * b,
+ const std::complex<double> *b,
const dealii::types::blas_int *ldb,
- const std::complex<double> * beta,
- std::complex<double> * c,
+ const std::complex<double> *beta,
+ std::complex<double> *c,
const dealii::types::blas_int *ldc)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-gemv(const char * trans,
+gemv(const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const float * alpha,
- const float * a,
+ const float *alpha,
+ const float *a,
const dealii::types::blas_int *lda,
- const float * x,
+ const float *x,
const dealii::types::blas_int *incx,
- const float * beta,
- float * y,
+ const float *beta,
+ float *y,
const dealii::types::blas_int *incy)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-gemv(const char * trans,
+gemv(const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const double * alpha,
- const double * a,
+ const double *alpha,
+ const double *a,
const dealii::types::blas_int *lda,
- const double * x,
+ const double *x,
const dealii::types::blas_int *incx,
- const double * beta,
- double * y,
+ const double *beta,
+ double *y,
const dealii::types::blas_int *incy)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-gemv(const char * trans,
+gemv(const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const std::complex<float> * alpha,
- const std::complex<float> * a,
+ const std::complex<float> *alpha,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- const std::complex<float> * x,
+ const std::complex<float> *x,
const dealii::types::blas_int *incx,
- const std::complex<float> * beta,
- std::complex<float> * y,
+ const std::complex<float> *beta,
+ std::complex<float> *y,
const dealii::types::blas_int *incy)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-gemv(const char * trans,
+gemv(const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const std::complex<double> * alpha,
- const std::complex<double> * a,
+ const std::complex<double> *alpha,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- const std::complex<double> * x,
+ const std::complex<double> *x,
const dealii::types::blas_int *incx,
- const std::complex<double> * beta,
- std::complex<double> * y,
+ const std::complex<double> *beta,
+ std::complex<double> *y,
const dealii::types::blas_int *incy)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
geqrf(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * tau,
- float * work,
+ float *tau,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sgeqrf, SGEQRF)(m, n, a, lda, tau, work, lwork, info);
inline void
geqrf(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * tau,
- double * work,
+ double *tau,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dgeqrf, DGEQRF)(m, n, a, lda, tau, work, lwork, info);
inline void
geqrf(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * tau,
- std::complex<float> * work,
+ std::complex<float> *tau,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cgeqrf, CGEQRF)(m, n, a, lda, tau, work, lwork, info);
inline void
geqrf(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * tau,
- std::complex<double> * work,
+ std::complex<double> *tau,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zgeqrf, ZGEQRF)(m, n, a, lda, tau, work, lwork, info);
inline void
-gesdd(const char * jobz,
+gesdd(const char *jobz,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * s,
- float * u,
+ float *s,
+ float *u,
const dealii::types::blas_int *ldu,
- float * vt,
+ float *vt,
const dealii::types::blas_int *ldvt,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sgesdd, SGESDD)
inline void
-gesdd(const char * jobz,
+gesdd(const char *jobz,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * s,
- double * u,
+ double *s,
+ double *u,
const dealii::types::blas_int *ldu,
- double * vt,
+ double *vt,
const dealii::types::blas_int *ldvt,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dgesdd, DGESDD)
inline void
-gesdd(const char * jobz,
+gesdd(const char *jobz,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- float * s,
- std::complex<float> * u,
+ float *s,
+ std::complex<float> *u,
const dealii::types::blas_int *ldu,
- std::complex<float> * vt,
+ std::complex<float> *vt,
const dealii::types::blas_int *ldvt,
- std::complex<float> * work,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- float * rwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ float *rwork,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cgesdd, CGESDD)
inline void
-gesdd(const char * jobz,
+gesdd(const char *jobz,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- double * s,
- std::complex<double> * u,
+ double *s,
+ std::complex<double> *u,
const dealii::types::blas_int *ldu,
- std::complex<double> * vt,
+ std::complex<double> *vt,
const dealii::types::blas_int *ldvt,
- std::complex<double> * work,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- double * rwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ double *rwork,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zgesdd, ZGESDD)
inline void
-gesvd(const char * jobu,
- const char * jobvt,
+gesvd(const char *jobu,
+ const char *jobvt,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * s,
- float * u,
+ float *s,
+ float *u,
const dealii::types::blas_int *ldu,
- float * vt,
+ float *vt,
const dealii::types::blas_int *ldvt,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sgesvd, SGESVD)
inline void
-gesvd(const char * jobu,
- const char * jobvt,
+gesvd(const char *jobu,
+ const char *jobvt,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * s,
- double * u,
+ double *s,
+ double *u,
const dealii::types::blas_int *ldu,
- double * vt,
+ double *vt,
const dealii::types::blas_int *ldvt,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dgesvd, DGESVD)
inline void
-gesvd(const char * jobu,
- const char * jobvt,
+gesvd(const char *jobu,
+ const char *jobvt,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- float * s,
- std::complex<float> * u,
+ float *s,
+ std::complex<float> *u,
const dealii::types::blas_int *ldu,
- std::complex<float> * vt,
+ std::complex<float> *vt,
const dealii::types::blas_int *ldvt,
- std::complex<float> * work,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- float * rwork,
- dealii::types::blas_int * info)
+ float *rwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cgesvd, CGESVD)
inline void
-gesvd(const char * jobu,
- const char * jobvt,
+gesvd(const char *jobu,
+ const char *jobvt,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- double * s,
- std::complex<double> * u,
+ double *s,
+ std::complex<double> *u,
const dealii::types::blas_int *ldu,
- std::complex<double> * vt,
+ std::complex<double> *vt,
const dealii::types::blas_int *ldvt,
- std::complex<double> * work,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- double * rwork,
- dealii::types::blas_int * info)
+ double *rwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zgesvd, ZGESVD)
inline void
getrf(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * ipiv,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *ipiv,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sgetrf, SGETRF)(m, n, a, lda, ipiv, info);
inline void
getrf(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * ipiv,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *ipiv,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dgetrf, DGETRF)(m, n, a, lda, ipiv, info);
inline void
getrf(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * ipiv,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *ipiv,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cgetrf, CGETRF)(m, n, a, lda, ipiv, info);
inline void
getrf(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * ipiv,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *ipiv,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zgetrf, ZGETRF)(m, n, a, lda, ipiv, info);
inline void
getri(const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sgetri, SGETRI)(n, a, lda, ipiv, work, lwork, info);
inline void
getri(const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dgetri, DGETRI)(n, a, lda, ipiv, work, lwork, info);
inline void
getri(const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- std::complex<float> * work,
+ std::complex<float> *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cgetri, CGETRI)(n, a, lda, ipiv, work, lwork, info);
inline void
getri(const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- std::complex<double> * work,
+ std::complex<double> *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zgetri, ZGETRI)(n, a, lda, ipiv, work, lwork, info);
inline void
-getrs(const char * trans,
+getrs(const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sgetrs, SGETRS)
inline void
-getrs(const char * trans,
+getrs(const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dgetrs, DGETRS)
inline void
-getrs(const char * trans,
+getrs(const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- std::complex<float> * b,
+ std::complex<float> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cgetrs, CGETRS)
inline void
-getrs(const char * trans,
+getrs(const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
const dealii::types::blas_int *ipiv,
- std::complex<double> * b,
+ std::complex<double> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zgetrs, ZGETRS)
inline float
-lange(const char * norm,
+lange(const char *norm,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * work)
+ float *work)
{
#ifdef DEAL_II_WITH_LAPACK
return DEAL_II_FORTRAN_MANGLE(slange, SLANGE)(norm, m, n, a, lda, work);
inline double
-lange(const char * norm,
+lange(const char *norm,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * work)
+ double *work)
{
#ifdef DEAL_II_WITH_LAPACK
return DEAL_II_FORTRAN_MANGLE(dlange, DLANGE)(norm, m, n, a, lda, work);
inline float
-lange(const char * norm,
+lange(const char *norm,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- float * work)
+ float *work)
{
#ifdef DEAL_II_WITH_LAPACK
return DEAL_II_FORTRAN_MANGLE(clange, CLANGE)(norm, m, n, a, lda, work);
inline double
-lange(const char * norm,
+lange(const char *norm,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- double * work)
+ double *work)
{
#ifdef DEAL_II_WITH_LAPACK
return DEAL_II_FORTRAN_MANGLE(zlange, ZLANGE)(norm, m, n, a, lda, work);
inline float
-lansy(const char * norm,
- const char * uplo,
+lansy(const char *norm,
+ const char *uplo,
const dealii::types::blas_int *n,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * work)
+ float *work)
{
#ifdef DEAL_II_WITH_LAPACK
return DEAL_II_FORTRAN_MANGLE(slansy, SLANSY)(norm, uplo, n, a, lda, work);
inline double
-lansy(const char * norm,
- const char * uplo,
+lansy(const char *norm,
+ const char *uplo,
const dealii::types::blas_int *n,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * work)
+ double *work)
{
#ifdef DEAL_II_WITH_LAPACK
return DEAL_II_FORTRAN_MANGLE(dlansy, DLANSY)(norm, uplo, n, a, lda, work);
inline float
-lansy(const char * norm,
- const char * uplo,
+lansy(const char *norm,
+ const char *uplo,
const dealii::types::blas_int *n,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- float * work)
+ float *work)
{
#ifdef DEAL_II_WITH_LAPACK
return DEAL_II_FORTRAN_MANGLE(clansy, CLANSY)(norm, uplo, n, a, lda, work);
inline double
-lansy(const char * norm,
- const char * uplo,
+lansy(const char *norm,
+ const char *uplo,
const dealii::types::blas_int *n,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- double * work)
+ double *work)
{
#ifdef DEAL_II_WITH_LAPACK
return DEAL_II_FORTRAN_MANGLE(zlansy, ZLANSY)(norm, uplo, n, a, lda, work);
inline void
-lascl(const char * type,
+lascl(const char *type,
const dealii::types::blas_int *kl,
const dealii::types::blas_int *ku,
- const float * cfrom,
- const float * cto,
+ const float *cfrom,
+ const float *cto,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(slascl, SLASCL)
inline void
-lascl(const char * type,
+lascl(const char *type,
const dealii::types::blas_int *kl,
const dealii::types::blas_int *ku,
- const double * cfrom,
- const double * cto,
+ const double *cfrom,
+ const double *cto,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dlascl, DLASCL)
inline void
-lascl(const char * type,
+lascl(const char *type,
const dealii::types::blas_int *kl,
const dealii::types::blas_int *ku,
- const float * cfrom,
- const float * cto,
+ const float *cfrom,
+ const float *cto,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(clascl, CLASCL)
inline void
-lascl(const char * type,
+lascl(const char *type,
const dealii::types::blas_int *kl,
const dealii::types::blas_int *ku,
- const double * cfrom,
- const double * cto,
+ const double *cfrom,
+ const double *cto,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zlascl, ZLASCL)
orgqr(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- const float * tau,
- float * work,
+ const float *tau,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sorgqr, SORGQR)
orgqr(const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- const double * tau,
- double * work,
+ const double *tau,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dorgqr, DORGQR)
inline void
-ormqr(const char * side,
- const char * trans,
+ormqr(const char *side,
+ const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- const float * tau,
- float * c,
+ const float *tau,
+ float *c,
const dealii::types::blas_int *ldc,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sormqr, SORMQR)
inline void
-ormqr(const char * side,
- const char * trans,
+ormqr(const char *side,
+ const char *trans,
const dealii::types::blas_int *m,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- const double * tau,
- double * c,
+ const double *tau,
+ double *c,
const dealii::types::blas_int *ldc,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dormqr, DORMQR)
inline void
-pocon(const char * uplo,
+pocon(const char *uplo,
const dealii::types::blas_int *n,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- const float * anorm,
- float * rcond,
- float * work,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ const float *anorm,
+ float *rcond,
+ float *work,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(spocon, SPOCON)
inline void
-pocon(const char * uplo,
+pocon(const char *uplo,
const dealii::types::blas_int *n,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- const double * anorm,
- double * rcond,
- double * work,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ const double *anorm,
+ double *rcond,
+ double *work,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dpocon, DPOCON)
inline void
-pocon(const char * uplo,
+pocon(const char *uplo,
const dealii::types::blas_int *n,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- const float * anorm,
- float * rcond,
- std::complex<float> * work,
- float * rwork,
- dealii::types::blas_int * info)
+ const float *anorm,
+ float *rcond,
+ std::complex<float> *work,
+ float *rwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cpocon, CPOCON)
inline void
-pocon(const char * uplo,
+pocon(const char *uplo,
const dealii::types::blas_int *n,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- const double * anorm,
- double * rcond,
- std::complex<double> * work,
- double * rwork,
- dealii::types::blas_int * info)
+ const double *anorm,
+ double *rcond,
+ std::complex<double> *work,
+ double *rwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zpocon, ZPOCON)
inline void
-potrf(const char * uplo,
+potrf(const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(spotrf, SPOTRF)(uplo, n, a, lda, info);
inline void
-potrf(const char * uplo,
+potrf(const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dpotrf, DPOTRF)(uplo, n, a, lda, info);
inline void
-potrf(const char * uplo,
+potrf(const char *uplo,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cpotrf, CPOTRF)(uplo, n, a, lda, info);
inline void
-potrf(const char * uplo,
+potrf(const char *uplo,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zpotrf, ZPOTRF)(uplo, n, a, lda, info);
inline void
-potri(const char * uplo,
+potri(const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(spotri, SPOTRI)(uplo, n, a, lda, info);
inline void
-potri(const char * uplo,
+potri(const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dpotri, DPOTRI)(uplo, n, a, lda, info);
inline void
-potri(const char * uplo,
+potri(const char *uplo,
const dealii::types::blas_int *n,
- std::complex<float> * a,
+ std::complex<float> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cpotri, CPOTRI)(uplo, n, a, lda, info);
inline void
-potri(const char * uplo,
+potri(const char *uplo,
const dealii::types::blas_int *n,
- std::complex<double> * a,
+ std::complex<double> *a,
const dealii::types::blas_int *lda,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zpotri, ZPOTRI)(uplo, n, a, lda, info);
inline void
-potrs(const char * uplo,
+potrs(const char *uplo,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(spotrs, SPOTRS)(uplo, n, nrhs, a, lda, b, ldb, info);
inline void
-potrs(const char * uplo,
+potrs(const char *uplo,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dpotrs, DPOTRS)(uplo, n, nrhs, a, lda, b, ldb, info);
inline void
-potrs(const char * uplo,
+potrs(const char *uplo,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * b,
+ std::complex<float> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(cpotrs, CPOTRS)(uplo, n, nrhs, a, lda, b, ldb, info);
inline void
-potrs(const char * uplo,
+potrs(const char *uplo,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * b,
+ std::complex<double> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(zpotrs, ZPOTRS)(uplo, n, nrhs, a, lda, b, ldb, info);
inline void
-stev(const char * jobz,
+stev(const char *jobz,
const dealii::types::blas_int *n,
- float * d,
- float * e,
- float * z,
+ float *d,
+ float *e,
+ float *z,
const dealii::types::blas_int *ldz,
- float * work,
- dealii::types::blas_int * info)
+ float *work,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(sstev, SSTEV)(jobz, n, d, e, z, ldz, work, info);
inline void
-stev(const char * jobz,
+stev(const char *jobz,
const dealii::types::blas_int *n,
- double * d,
- double * e,
- double * z,
+ double *d,
+ double *e,
+ double *z,
const dealii::types::blas_int *ldz,
- double * work,
- dealii::types::blas_int * info)
+ double *work,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dstev, DSTEV)(jobz, n, d, e, z, ldz, work, info);
inline void
-syev(const char * jobz,
- const char * uplo,
+syev(const char *jobz,
+ const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * w,
- float * work,
+ float *w,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(ssyev, SSYEV)
inline void
-syev(const char * jobz,
- const char * uplo,
+syev(const char *jobz,
+ const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * w,
- double * work,
+ double *w,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dsyev, DSYEV)
inline void
-syevr(const char * jobz,
- const char * range,
- const char * uplo,
+syevr(const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- const float * vl,
- const float * vu,
+ const float *vl,
+ const float *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const float * abstol,
- dealii::types::blas_int * m,
- float * w,
- float * z,
+ const float *abstol,
+ dealii::types::blas_int *m,
+ float *w,
+ float *z,
const dealii::types::blas_int *ldz,
- dealii::types::blas_int * isuppz,
- float * work,
+ dealii::types::blas_int *isuppz,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
+ dealii::types::blas_int *iwork,
const dealii::types::blas_int *liwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
// Netlib and Atlas Lapack perform floating point tests (e.g. divide-by-zero)
inline void
-syevr(const char * jobz,
- const char * range,
- const char * uplo,
+syevr(const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- const double * vl,
- const double * vu,
+ const double *vl,
+ const double *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const double * abstol,
- dealii::types::blas_int * m,
- double * w,
- double * z,
+ const double *abstol,
+ dealii::types::blas_int *m,
+ double *w,
+ double *z,
const dealii::types::blas_int *ldz,
- dealii::types::blas_int * isuppz,
- double * work,
+ dealii::types::blas_int *isuppz,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
+ dealii::types::blas_int *iwork,
const dealii::types::blas_int *liwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
// Netlib and Atlas Lapack perform floating point tests (e.g. divide-by-zero)
inline void
-syevx(const char * jobz,
- const char * range,
- const char * uplo,
+syevx(const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- const float * vl,
- const float * vu,
+ const float *vl,
+ const float *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const float * abstol,
- dealii::types::blas_int * m,
- float * w,
- float * z,
+ const float *abstol,
+ dealii::types::blas_int *m,
+ float *w,
+ float *z,
const dealii::types::blas_int *ldz,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * ifail,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *ifail,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(ssyevx, SSYEVX)
inline void
-syevx(const char * jobz,
- const char * range,
- const char * uplo,
+syevx(const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- const double * vl,
- const double * vu,
+ const double *vl,
+ const double *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const double * abstol,
- dealii::types::blas_int * m,
- double * w,
- double * z,
+ const double *abstol,
+ dealii::types::blas_int *m,
+ double *w,
+ double *z,
const dealii::types::blas_int *ldz,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * ifail,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *ifail,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dsyevx, DSYEVX)
inline void
sygv(const dealii::types::blas_int *itype,
- const char * jobz,
- const char * uplo,
+ const char *jobz,
+ const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- float * w,
- float * work,
+ float *w,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(ssygv, SSYGV)
inline void
sygv(const dealii::types::blas_int *itype,
- const char * jobz,
- const char * uplo,
+ const char *jobz,
+ const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- double * w,
- double * work,
+ double *w,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dsygv, DSYGV)
inline void
sygvx(const dealii::types::blas_int *itype,
- const char * jobz,
- const char * range,
- const char * uplo,
+ const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- float * a,
+ float *a,
const dealii::types::blas_int *lda,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- const float * vl,
- const float * vu,
+ const float *vl,
+ const float *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const float * abstol,
- dealii::types::blas_int * m,
- float * w,
- float * z,
+ const float *abstol,
+ dealii::types::blas_int *m,
+ float *w,
+ float *z,
const dealii::types::blas_int *ldz,
- float * work,
+ float *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * ifail,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *ifail,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(ssygvx, SSYGVX)
inline void
sygvx(const dealii::types::blas_int *itype,
- const char * jobz,
- const char * range,
- const char * uplo,
+ const char *jobz,
+ const char *range,
+ const char *uplo,
const dealii::types::blas_int *n,
- double * a,
+ double *a,
const dealii::types::blas_int *lda,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- const double * vl,
- const double * vu,
+ const double *vl,
+ const double *vu,
const dealii::types::blas_int *il,
const dealii::types::blas_int *iu,
- const double * abstol,
- dealii::types::blas_int * m,
- double * w,
- double * z,
+ const double *abstol,
+ dealii::types::blas_int *m,
+ double *w,
+ double *z,
const dealii::types::blas_int *ldz,
- double * work,
+ double *work,
const dealii::types::blas_int *lwork,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * ifail,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *ifail,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dsygvx, DSYGVX)
inline void
-syr(const char * uplo,
+syr(const char *uplo,
const dealii::types::blas_int *n,
- const float * alpha,
- const float * x,
+ const float *alpha,
+ const float *x,
const dealii::types::blas_int *incx,
- float * a,
+ float *a,
const dealii::types::blas_int *lda)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-syr(const char * uplo,
+syr(const char *uplo,
const dealii::types::blas_int *n,
- const double * alpha,
- const double * x,
+ const double *alpha,
+ const double *x,
const dealii::types::blas_int *incx,
- double * a,
+ double *a,
const dealii::types::blas_int *lda)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-syrk(const char * uplo,
- const char * trans,
+syrk(const char *uplo,
+ const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const float * alpha,
- const float * a,
+ const float *alpha,
+ const float *a,
const dealii::types::blas_int *lda,
- const float * beta,
- float * c,
+ const float *beta,
+ float *c,
const dealii::types::blas_int *ldc)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-syrk(const char * uplo,
- const char * trans,
+syrk(const char *uplo,
+ const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const double * alpha,
- const double * a,
+ const double *alpha,
+ const double *a,
const dealii::types::blas_int *lda,
- const double * beta,
- double * c,
+ const double *beta,
+ double *c,
const dealii::types::blas_int *ldc)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-syrk(const char * uplo,
- const char * trans,
+syrk(const char *uplo,
+ const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const std::complex<float> * alpha,
- const std::complex<float> * a,
+ const std::complex<float> *alpha,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- const std::complex<float> * beta,
- std::complex<float> * c,
+ const std::complex<float> *beta,
+ std::complex<float> *c,
const dealii::types::blas_int *ldc)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-syrk(const char * uplo,
- const char * trans,
+syrk(const char *uplo,
+ const char *trans,
const dealii::types::blas_int *n,
const dealii::types::blas_int *k,
- const std::complex<double> * alpha,
- const std::complex<double> * a,
+ const std::complex<double> *alpha,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- const std::complex<double> * beta,
- std::complex<double> * c,
+ const std::complex<double> *beta,
+ std::complex<double> *c,
const dealii::types::blas_int *ldc)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-trcon(const char * norm,
- const char * uplo,
- const char * diag,
+trcon(const char *norm,
+ const char *uplo,
+ const char *diag,
const dealii::types::blas_int *n,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * rcond,
- float * work,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ float *rcond,
+ float *work,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(strcon, STRCON)
inline void
-trcon(const char * norm,
- const char * uplo,
- const char * diag,
+trcon(const char *norm,
+ const char *uplo,
+ const char *diag,
const dealii::types::blas_int *n,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * rcond,
- double * work,
- dealii::types::blas_int * iwork,
- dealii::types::blas_int * info)
+ double *rcond,
+ double *work,
+ dealii::types::blas_int *iwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dtrcon, DTRCON)
inline void
-trcon(const char * norm,
- const char * uplo,
- const char * diag,
+trcon(const char *norm,
+ const char *uplo,
+ const char *diag,
const dealii::types::blas_int *n,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- float * rcond,
- std::complex<float> * work,
- float * rwork,
- dealii::types::blas_int * info)
+ float *rcond,
+ std::complex<float> *work,
+ float *rwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(ctrcon, CTRCON)
inline void
-trcon(const char * norm,
- const char * uplo,
- const char * diag,
+trcon(const char *norm,
+ const char *uplo,
+ const char *diag,
const dealii::types::blas_int *n,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- double * rcond,
- std::complex<double> * work,
- double * rwork,
- dealii::types::blas_int * info)
+ double *rcond,
+ std::complex<double> *work,
+ double *rwork,
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(ztrcon, ZTRCON)
inline void
-trmv(const char * uplo,
- const char * trans,
- const char * diag,
+trmv(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * x,
+ float *x,
const dealii::types::blas_int *incx)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-trmv(const char * uplo,
- const char * trans,
- const char * diag,
+trmv(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * x,
+ double *x,
const dealii::types::blas_int *incx)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-trmv(const char * uplo,
- const char * trans,
- const char * diag,
+trmv(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * x,
+ std::complex<float> *x,
const dealii::types::blas_int *incx)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-trmv(const char * uplo,
- const char * trans,
- const char * diag,
+trmv(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * x,
+ std::complex<double> *x,
const dealii::types::blas_int *incx)
{
#ifdef DEAL_II_WITH_LAPACK
inline void
-trtrs(const char * uplo,
- const char * trans,
- const char * diag,
+trtrs(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const float * a,
+ const float *a,
const dealii::types::blas_int *lda,
- float * b,
+ float *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(strtrs, STRTRS)
inline void
-trtrs(const char * uplo,
- const char * trans,
- const char * diag,
+trtrs(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const double * a,
+ const double *a,
const dealii::types::blas_int *lda,
- double * b,
+ double *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(dtrtrs, DTRTRS)
inline void
-trtrs(const char * uplo,
- const char * trans,
- const char * diag,
+trtrs(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<float> * a,
+ const std::complex<float> *a,
const dealii::types::blas_int *lda,
- std::complex<float> * b,
+ std::complex<float> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(ctrtrs, CTRTRS)
inline void
-trtrs(const char * uplo,
- const char * trans,
- const char * diag,
+trtrs(const char *uplo,
+ const char *trans,
+ const char *diag,
const dealii::types::blas_int *n,
const dealii::types::blas_int *nrhs,
- const std::complex<double> * a,
+ const std::complex<double> *a,
const dealii::types::blas_int *lda,
- std::complex<double> * b,
+ std::complex<double> *b,
const dealii::types::blas_int *ldb,
- dealii::types::blas_int * info)
+ dealii::types::blas_int *info)
{
#ifdef DEAL_II_WITH_LAPACK
DEAL_II_FORTRAN_MANGLE(ztrtrs, ZTRTRS)
typename Domain,
typename Payload>
LinearOperator<Range, Domain, Payload>
-operator*(const LinearOperator<Range, Intermediate, Payload> & first_op,
+operator*(const LinearOperator<Range, Intermediate, Payload> &first_op,
const LinearOperator<Intermediate, Domain, Payload> &second_op)
{
if (first_op.is_null_operator || second_op.is_null_operator)
typename Domain = Range>
LinearOperator<Domain, Range, Payload>
inverse_operator(const LinearOperator<Range, Domain, Payload> &op,
- Solver & solver,
- const Preconditioner & preconditioner)
+ Solver &solver,
+ const Preconditioner &preconditioner)
{
LinearOperator<Domain, Range, Payload> return_op{
op.inverse_payload(solver, preconditioner)};
solver.solve(op, v, u, preconditioner);
};
- return_op.vmult_add = [op, &solver, &preconditioner](Range & v,
+ return_op.vmult_add = [op, &solver, &preconditioner](Range &v,
const Domain &u) {
GrowingVectorMemory<Range> vector_memory;
solver.solve(transpose_operator(op), v, u, preconditioner);
};
- return_op.Tvmult_add = [op, &solver, &preconditioner](Range & v,
+ return_op.Tvmult_add = [op, &solver, &preconditioner](Range &v,
const Domain &u) {
GrowingVectorMemory<Range> vector_memory;
typename Domain = Range>
LinearOperator<Domain, Range, Payload>
inverse_operator(const LinearOperator<Range, Domain, Payload> &op,
- Solver & solver,
+ Solver &solver,
const LinearOperator<Range, Domain, Payload> &preconditioner)
{
LinearOperator<Domain, Range, Payload> return_op{
solver.solve(op, v, u, preconditioner);
};
- return_op.vmult_add = [op, &solver, preconditioner](Range & v,
+ return_op.vmult_add = [op, &solver, preconditioner](Range &v,
const Domain &u) {
GrowingVectorMemory<Range> vector_memory;
solver.solve(transpose_operator(op), v, u, preconditioner);
};
- return_op.Tvmult_add = [op, &solver, preconditioner](Range & v,
+ return_op.Tvmult_add = [op, &solver, preconditioner](Range &v,
const Domain &u) {
GrowingVectorMemory<Range> vector_memory;
typename Domain = Range>
LinearOperator<Domain, Range, Payload>
inverse_operator(const LinearOperator<Range, Domain, Payload> &op,
- Solver & solver)
+ Solver &solver)
{
return inverse_operator(op, solver, identity_operator(op));
}
typename Domain = Range>
LinearOperator<Domain, Range, Payload>
inverse_operator(const LinearOperator<Range, Domain, Payload> &op,
- Solver & solver,
+ Solver &solver,
const PreconditionIdentity &)
{
return inverse_operator(op, solver);
template <typename Matrix>
static void
reinit_range_vector(const Matrix &matrix,
- Vector & v,
+ Vector &v,
bool omit_zeroing_entries)
{
v.reinit(matrix.m(), omit_zeroing_entries);
template <typename Matrix>
static void
reinit_domain_vector(const Matrix &matrix,
- Vector & v,
+ Vector &v,
bool omit_zeroing_entries)
{
v.reinit(matrix.n(), omit_zeroing_entries);
template <typename Function, typename Range, typename Domain>
void
apply_with_intermediate_storage(Function function,
- Range & v,
+ Range &v,
const Domain &u,
bool add)
{
template <typename Matrix>
void
operator()(LinearOperator<Range, Domain, Payload> &op,
- const Matrix & matrix)
+ const Matrix &matrix)
{
op.vmult = [&matrix](Range &v, const Domain &u) {
if (PointerComparison::equal(&v, &u))
template <typename Matrix>
void
operator()(LinearOperator<Range, Domain, Payload> &op,
- const Matrix & matrix)
+ const Matrix &matrix)
{
// As above ...
template <typename Range, typename Domain, typename Payload, typename Matrix>
LinearOperator<Range, Domain, Payload>
linear_operator(const LinearOperator<Range, Domain, Payload> &operator_exemplar,
- const Matrix & matrix)
+ const Matrix &matrix)
{
using namespace internal::LinearOperatorImplementation;
// Initialize the payload based on the LinearOperator exemplar
template <typename number>
void
reinit(MatrixBlock<dealii::SparseMatrix<number>> &v,
- const BlockSparsityPattern & p);
+ const BlockSparsityPattern &p);
} // namespace internal
/**
template <typename number>
void
add(const std::vector<size_type> &indices,
- const FullMatrix<number> & full_matrix,
+ const FullMatrix<number> &full_matrix,
const bool elide_zero_values = true);
/**
void
add(const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- const FullMatrix<number> & full_matrix,
+ const FullMatrix<number> &full_matrix,
const bool elide_zero_values = true);
/**
void
add(const size_type row_index,
const std::vector<size_type> &col_indices,
- const std::vector<number> & values,
+ const std::vector<number> &values,
const bool elide_zero_values = true);
/**
add(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number * values,
+ const number *values,
const bool elide_zero_values = true,
const bool col_indices_are_sorted = false);
template <typename number>
friend void
internal::reinit(MatrixBlock<dealii::SparseMatrix<number>> &v,
- const BlockSparsityPattern & p);
+ const BlockSparsityPattern &p);
};
template <typename number>
void
reinit(MatrixBlock<dealii::SparseMatrix<number>> &v,
- const BlockSparsityPattern & p)
+ const BlockSparsityPattern &p)
{
v.row_indices = p.get_row_indices();
v.column_indices = p.get_column_indices();
inline void
MatrixBlock<MatrixType>::add(const std::vector<size_type> &r_indices,
const std::vector<size_type> &c_indices,
- const FullMatrix<number> & values,
+ const FullMatrix<number> &values,
const bool elide_zero_values)
{
Assert(row_indices.size() != 0, ExcNotInitialized());
MatrixBlock<MatrixType>::add(const size_type b_row,
const size_type n_cols,
const size_type *col_indices,
- const number * values,
+ const number *values,
const bool,
const bool)
{
// leave it at this. While it may
// not be the most efficient way,
// it is at least thread safe.
- //#ifdef DEBUG
+ // #ifdef DEBUG
Assert(bi.first == row, ExcBlockIndexMismatch(bi.first, row));
for (size_type j = 0; j < n_cols; ++j)
matrix.add(bi.second, bj.second, values[j]);
}
- //#endif
+ // #endif
}
template <typename number>
inline void
MatrixBlock<MatrixType>::add(const std::vector<size_type> &indices,
- const FullMatrix<number> & values,
+ const FullMatrix<number> &values,
const bool elide_zero_values)
{
Assert(row_indices.size() != 0, ExcNotInitialized());
inline void
MatrixBlock<MatrixType>::add(const size_type row,
const std::vector<size_type> &col_indices,
- const std::vector<number> & values,
+ const std::vector<number> &values,
const bool elide_zero_values)
{
Assert(row_indices.size() != 0, ExcNotInitialized());
* Constructor. Create an iterator into the matrix <tt>matrix</tt> for the
* given <tt>row</tt> and the <tt>index</tt> within it.
*/
- MatrixIterator(MatrixType * matrix,
+ MatrixIterator(MatrixType *matrix,
const size_type row = 0,
const size_type index = 0);
//----------------------------------------------------------------------//
template <class ACCESSOR>
-inline MatrixIterator<ACCESSOR>::MatrixIterator(MatrixType * matrix,
+inline MatrixIterator<ACCESSOR>::MatrixIterator(MatrixType *matrix,
const size_type r,
const size_type i)
: accessor(matrix, r, i)
*/
template <class Matrix>
void
- build_patches(const Matrix & matrix,
+ build_patches(const Matrix &matrix,
const std::string &name,
const Options options = Options(false, 1, false));
*/
template <class Matrix>
static double
- get_gridpoint_value(const Matrix & matrix,
+ get_gridpoint_value(const Matrix &matrix,
const size_type i,
const size_type j,
- const Options & options);
+ const Options &options);
};
*/
template <class Matrix>
double
- get_element(const Matrix & matrix,
+ get_element(const Matrix &matrix,
const types::global_dof_index i,
const types::global_dof_index j)
{
template <class Matrix>
inline double
-MatrixOut::get_gridpoint_value(const Matrix & matrix,
+MatrixOut::get_gridpoint_value(const Matrix &matrix,
const size_type i,
const size_type j,
- const Options & options)
+ const Options &options)
{
// special case if block size is
// one since we then don't need all
template <class Matrix>
void
-MatrixOut::build_patches(const Matrix & matrix,
+MatrixOut::build_patches(const Matrix &matrix,
const std::string &name,
const Options options)
{
template <typename Range, typename Domain, typename Payload>
PackagedOperation<Range>
operator*(const LinearOperator<Range, Domain, Payload> &op,
- const PackagedOperation<Domain> & comp)
+ const PackagedOperation<Domain> &comp)
{
PackagedOperation<Range> return_comp;
*/
template <typename Range, typename Domain, typename Payload>
PackagedOperation<Domain>
-operator*(const PackagedOperation<Range> & comp,
+operator*(const PackagedOperation<Range> &comp,
const LinearOperator<Range, Domain, Payload> &op)
{
PackagedOperation<Range> return_comp;
// http://www.mathkeisan.com/usersguide/man/pdnaupd.html
void
pdnaupd_(MPI_Fint *comm,
- int * ido,
- char * bmat,
- int * n,
- char * which,
- int * nev,
- double * tol,
- double * resid,
- int * ncv,
- double * v,
- int * nloc,
- int * iparam,
- int * ipntr,
- double * workd,
- double * workl,
- int * lworkl,
- int * info);
+ int *ido,
+ char *bmat,
+ int *n,
+ char *which,
+ int *nev,
+ double *tol,
+ double *resid,
+ int *ncv,
+ double *v,
+ int *nloc,
+ int *iparam,
+ int *ipntr,
+ double *workd,
+ double *workl,
+ int *lworkl,
+ int *info);
// http://www.mathkeisan.com/usersguide/man/pdsaupd.html
void
pdsaupd_(MPI_Fint *comm,
- int * ido,
- char * bmat,
- int * n,
- char * which,
- int * nev,
- double * tol,
- double * resid,
- int * ncv,
- double * v,
- int * nloc,
- int * iparam,
- int * ipntr,
- double * workd,
- double * workl,
- int * lworkl,
- int * info);
+ int *ido,
+ char *bmat,
+ int *n,
+ char *which,
+ int *nev,
+ double *tol,
+ double *resid,
+ int *ncv,
+ double *v,
+ int *nloc,
+ int *iparam,
+ int *ipntr,
+ double *workd,
+ double *workl,
+ int *lworkl,
+ int *info);
// http://www.mathkeisan.com/usersguide/man/pdneupd.html
void
pdneupd_(MPI_Fint *comm,
- int * rvec,
- char * howmany,
- int * select,
- double * d,
- double * di,
- double * z,
- int * ldz,
- double * sigmar,
- double * sigmai,
- double * workev,
- char * bmat,
- int * n,
- char * which,
- int * nev,
- double * tol,
- double * resid,
- int * ncv,
- double * v,
- int * nloc,
- int * iparam,
- int * ipntr,
- double * workd,
- double * workl,
- int * lworkl,
- int * info);
+ int *rvec,
+ char *howmany,
+ int *select,
+ double *d,
+ double *di,
+ double *z,
+ int *ldz,
+ double *sigmar,
+ double *sigmai,
+ double *workev,
+ char *bmat,
+ int *n,
+ char *which,
+ int *nev,
+ double *tol,
+ double *resid,
+ int *ncv,
+ double *v,
+ int *nloc,
+ int *iparam,
+ int *ipntr,
+ double *workd,
+ double *workl,
+ int *lworkl,
+ int *info);
// http://www.mathkeisan.com/usersguide/man/pdseupd.html
void
pdseupd_(MPI_Fint *comm,
- int * rvec,
- char * howmany,
- int * select,
- double * d,
- double * z,
- int * ldz,
- double * sigmar,
- char * bmat,
- int * n,
- char * which,
- int * nev,
- double * tol,
- double * resid,
- int * ncv,
- double * v,
- int * nloc,
- int * iparam,
- int * ipntr,
- double * workd,
- double * workl,
- int * lworkl,
- int * info);
+ int *rvec,
+ char *howmany,
+ int *select,
+ double *d,
+ double *z,
+ int *ldz,
+ double *sigmar,
+ char *bmat,
+ int *n,
+ char *which,
+ int *nev,
+ double *tol,
+ double *resid,
+ int *ncv,
+ double *v,
+ int *nloc,
+ int *iparam,
+ int *ipntr,
+ double *workd,
+ double *workl,
+ int *lworkl,
+ int *info);
// other resources:
// http://acts.nersc.gov/superlu/example5/pnslac.c.html
/**
* Constructor.
*/
- PArpackSolver(SolverControl & control,
+ PArpackSolver(SolverControl &control,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* blockvectors used.
*/
void
- reinit(const IndexSet & locally_owned_dofs,
+ reinit(const IndexSet &locally_owned_dofs,
const std::vector<IndexSet> &partitioning);
/**
*/
template <typename MatrixType1, typename MatrixType2, typename INVERSE>
void
- solve(const MatrixType1 & A,
- const MatrixType2 & B,
- const INVERSE & inverse,
+ solve(const MatrixType1 &A,
+ const MatrixType2 &B,
+ const INVERSE &inverse,
std::vector<std::complex<double>> &eigenvalues,
- std::vector<VectorType> & eigenvectors,
+ std::vector<VectorType> &eigenvectors,
const unsigned int n_eigenvalues);
/**
*/
template <typename MatrixType1, typename MatrixType2, typename INVERSE>
void
- solve(const MatrixType1 & A,
- const MatrixType2 & B,
- const INVERSE & inverse,
+ solve(const MatrixType1 &A,
+ const MatrixType2 &B,
+ const INVERSE &inverse,
std::vector<std::complex<double>> &eigenvalues,
- std::vector<VectorType *> & eigenvectors,
+ std::vector<VectorType *> &eigenvectors,
const unsigned int n_eigenvalues);
/**
template <typename VectorType>
-PArpackSolver<VectorType>::PArpackSolver(SolverControl & control,
+PArpackSolver<VectorType>::PArpackSolver(SolverControl &control,
const MPI_Comm mpi_communicator,
const AdditionalData &data)
: solver_control(control)
template <typename VectorType>
template <typename MatrixType1, typename MatrixType2, typename INVERSE>
void
-PArpackSolver<VectorType>::solve(const MatrixType1 & A,
- const MatrixType2 & B,
- const INVERSE & inverse,
+PArpackSolver<VectorType>::solve(const MatrixType1 &A,
+ const MatrixType2 &B,
+ const INVERSE &inverse,
std::vector<std::complex<double>> &eigenvalues,
std::vector<VectorType> &eigenvectors,
const unsigned int n_eigenvalues)
void
PArpackSolver<VectorType>::solve(const MatrixType1 &system_matrix,
const MatrixType2 &mass_matrix,
- const INVERSE & inverse,
+ const INVERSE &inverse,
std::vector<std::complex<double>> &eigenvalues,
std::vector<VectorType *> &eigenvectors,
const unsigned int n_eigenvalues)
* arguments.
*/
void
- reinit(const std::vector<IndexSet> & rows,
- const std::vector<IndexSet> & cols,
+ reinit(const std::vector<IndexSet> &rows,
+ const std::vector<IndexSet> &cols,
const BlockDynamicSparsityPattern &bdsp,
const MPI_Comm com);
* Same as above but for a symmetric structure only.
*/
void
- reinit(const std::vector<IndexSet> & sizes,
+ reinit(const std::vector<IndexSet> &sizes,
const BlockDynamicSparsityPattern &bdsp,
const MPI_Comm com);
void
reinit(
const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
- & partitioners,
+ &partitioners,
const bool make_ghosted = true);
/**
* Print to a stream.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const bool across = true) const;
inline void
BlockVector::reinit(
const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
- & partitioners,
+ &partitioners,
const bool make_ghosted)
{
// update the number of blocks
inline void
- BlockVector::print(std::ostream & out,
+ BlockVector::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool across) const
public:
template <typename Matrix>
static void
- reinit_range_vector(const Matrix & matrix,
+ reinit_range_vector(const Matrix &matrix,
PETScWrappers::MPI::BlockVector &v,
bool /*omit_zeroing_entries*/)
{
template <typename Matrix>
static void
- reinit_domain_vector(const Matrix & matrix,
+ reinit_domain_vector(const Matrix &matrix,
PETScWrappers::MPI::BlockVector &v,
bool /*omit_zeroing_entries*/)
{
*/
void
reinit(const types::global_dof_index local_size,
- const IndexSet & ghost_indices,
+ const IndexSet &ghost_indices,
const MPI_Comm communicator);
/**
template <typename Number>
void
export_to_ghosted_array(const ArrayView<const Number> &locally_owned_array,
- const ArrayView<Number> & ghost_array) const;
+ const ArrayView<Number> &ghost_array) const;
/**
* Start the communication round to fill the vector @p ghost_array according
void
export_to_ghosted_array_start(
const ArrayView<const Number> &locally_owned_array,
- const ArrayView<Number> & ghost_array) const;
+ const ArrayView<Number> &ghost_array) const;
/**
* Finish the communication round to fill the vector @p ghost_array according
void
export_to_ghosted_array_finish(
const ArrayView<const Number> &locally_owned_array,
- const ArrayView<Number> & ghost_array) const;
+ const ArrayView<Number> &ghost_array) const;
/**
* Modify the vector @p locally_owned_array according to the precomputed communication
import_from_ghosted_array(
const VectorOperation::values op,
const ArrayView<const Number> &ghost_array,
- const ArrayView<Number> & locally_owned_array) const;
+ const ArrayView<Number> &locally_owned_array) const;
/**
* Start the communication round to modify the vector @p locally_owned_array according
import_from_ghosted_array_start(
const VectorOperation::values op,
const ArrayView<const Number> &ghost_array,
- const ArrayView<Number> & locally_owned_array) const;
+ const ArrayView<Number> &locally_owned_array) const;
/**
* Finish the communication round to modify the vector @p locally_owned_array according
import_from_ghosted_array_finish(
const VectorOperation::values op,
const ArrayView<const Number> &ghost_array,
- const ArrayView<Number> & locally_owned_array) const;
+ const ArrayView<Number> &locally_owned_array) const;
/**
* Return the underlying MPI communicator.
template <typename Number>
void
export_to_ghosted_array(const ArrayView<const Number> &locally_owned_array,
- const ArrayView<Number> & ghost_array) const;
+ const ArrayView<Number> &ghost_array) const;
/**
* Start the communication round to fill the vector @p ghost_array according
void
export_to_ghosted_array_start(
const ArrayView<const Number> &locally_owned_array,
- const ArrayView<Number> & ghost_array) const;
+ const ArrayView<Number> &ghost_array) const;
/**
* Finish the communication round to fill the vector @p ghost_array according
void
export_to_ghosted_array_finish(
const ArrayView<const Number> &locally_owned_array,
- const ArrayView<Number> & ghost_array) const;
+ const ArrayView<Number> &ghost_array) const;
/**
* Modify the vector @p locally_owned_array according to the precomputed communication
import_from_ghosted_array(
const VectorOperation::values op,
const ArrayView<const Number> &ghost_array,
- const ArrayView<Number> & locally_owned_array) const;
+ const ArrayView<Number> &locally_owned_array) const;
/**
* Start the communication round to modify the vector @p locally_owned_array according
import_from_ghosted_array_start(
const VectorOperation::values op,
const ArrayView<const Number> &ghost_array,
- const ArrayView<Number> & locally_owned_array) const;
+ const ArrayView<Number> &locally_owned_array) const;
/**
* Finish the communication round to modify the vector @p locally_owned_array according
import_from_ghosted_array_finish(
const VectorOperation::values op,
const ArrayView<const Number> &ghost_array,
- const ArrayView<Number> & locally_owned_array) const;
+ const ArrayView<Number> &locally_owned_array) const;
/**
* Return the underlying MPI communicator.
* before 3.0.0 since the corresponding function did not take this argument.
*/
inline void
- set_matrix_option(Mat & matrix,
+ set_matrix_option(Mat &matrix,
const MatOption option_name,
const PetscBool option_value = PETSC_FALSE)
{
* values are inserted/replaced.
*/
void
- set(const std::vector<size_type> & indices,
+ set(const std::vector<size_type> &indices,
const FullMatrix<PetscScalar> &full_matrix,
const bool elide_zero_values = false);
* rows and columns, respectively.
*/
void
- set(const std::vector<size_type> & row_indices,
- const std::vector<size_type> & col_indices,
+ set(const std::vector<size_type> &row_indices,
+ const std::vector<size_type> &col_indices,
const FullMatrix<PetscScalar> &full_matrix,
const bool elide_zero_values = false);
*/
void
set(const size_type row,
- const std::vector<size_type> & col_indices,
+ const std::vector<size_type> &col_indices,
const std::vector<PetscScalar> &values,
const bool elide_zero_values = false);
void
set(const size_type row,
const size_type n_cols,
- const size_type * col_indices,
+ const size_type *col_indices,
const PetscScalar *values,
const bool elide_zero_values = false);
* <tt>true</tt>, i.e., zero values won't be added into the matrix.
*/
void
- add(const std::vector<size_type> & indices,
+ add(const std::vector<size_type> &indices,
const FullMatrix<PetscScalar> &full_matrix,
const bool elide_zero_values = true);
* rows and columns, respectively.
*/
void
- add(const std::vector<size_type> & row_indices,
- const std::vector<size_type> & col_indices,
+ add(const std::vector<size_type> &row_indices,
+ const std::vector<size_type> &col_indices,
const FullMatrix<PetscScalar> &full_matrix,
const bool elide_zero_values = true);
*/
void
add(const size_type row,
- const std::vector<size_type> & col_indices,
+ const std::vector<size_type> &col_indices,
const std::vector<PetscScalar> &values,
const bool elide_zero_values = true);
void
add(const size_type row,
const size_type n_cols,
- const size_type * col_indices,
+ const size_type *col_indices,
const PetscScalar *values,
const bool elide_zero_values = true,
const bool col_indices_are_sorted = false);
inline void
- MatrixBase::set(const std::vector<size_type> & indices,
+ MatrixBase::set(const std::vector<size_type> &indices,
const FullMatrix<PetscScalar> &values,
const bool elide_zero_values)
{
inline void
- MatrixBase::set(const std::vector<size_type> & row_indices,
- const std::vector<size_type> & col_indices,
+ MatrixBase::set(const std::vector<size_type> &row_indices,
+ const std::vector<size_type> &col_indices,
const FullMatrix<PetscScalar> &values,
const bool elide_zero_values)
{
inline void
MatrixBase::set(const size_type row,
- const std::vector<size_type> & col_indices,
+ const std::vector<size_type> &col_indices,
const std::vector<PetscScalar> &values,
const bool elide_zero_values)
{
inline void
MatrixBase::set(const size_type row,
const size_type n_cols,
- const size_type * col_indices,
+ const size_type *col_indices,
const PetscScalar *values,
const bool elide_zero_values)
{
inline void
- MatrixBase::add(const std::vector<size_type> & indices,
+ MatrixBase::add(const std::vector<size_type> &indices,
const FullMatrix<PetscScalar> &values,
const bool elide_zero_values)
{
inline void
- MatrixBase::add(const std::vector<size_type> & row_indices,
- const std::vector<size_type> & col_indices,
+ MatrixBase::add(const std::vector<size_type> &row_indices,
+ const std::vector<size_type> &col_indices,
const FullMatrix<PetscScalar> &values,
const bool elide_zero_values)
{
inline void
MatrixBase::add(const size_type row,
- const std::vector<size_type> & col_indices,
+ const std::vector<size_type> &col_indices,
const std::vector<PetscScalar> &values,
const bool elide_zero_values)
{
inline void
MatrixBase::add(const size_type row,
const size_type n_cols,
- const size_type * col_indices,
+ const size_type *col_indices,
const PetscScalar *values,
const bool elide_zero_values,
const bool /*col_indices_are_sorted*/)
* and additional flags if there are any.
*/
PreconditionJacobi(
- const MatrixBase & matrix,
+ const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* used if you create the preconditioner without arguments.
*/
void
- initialize(const MatrixBase & matrix,
+ initialize(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
protected:
* and additional flags if there are any.
*/
PreconditionBlockJacobi(
- const MatrixBase & matrix,
+ const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* used if you create the preconditioner without arguments.
*/
void
- initialize(const MatrixBase & matrix,
+ initialize(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
protected:
* Constructor. Take the matrix which is used to form the preconditioner,
* and additional flags if there are any.
*/
- PreconditionSOR(const MatrixBase & matrix,
+ PreconditionSOR(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* used if you create the preconditioner without arguments.
*/
void
- initialize(const MatrixBase & matrix,
+ initialize(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
protected:
* Constructor. Take the matrix which is used to form the preconditioner,
* and additional flags if there are any.
*/
- PreconditionSSOR(const MatrixBase & matrix,
+ PreconditionSSOR(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* used if you create the preconditioner without arguments.
*/
void
- initialize(const MatrixBase & matrix,
+ initialize(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
protected:
* Constructor. Take the matrix which is used to form the preconditioner,
* and additional flags if there are any.
*/
- PreconditionICC(const MatrixBase & matrix,
+ PreconditionICC(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* used if you create the preconditioner without arguments.
*/
void
- initialize(const MatrixBase & matrix,
+ initialize(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
protected:
* Constructor. Take the matrix which is used to form the preconditioner,
* and additional flags if there are any.
*/
- PreconditionILU(const MatrixBase & matrix,
+ PreconditionILU(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* used if you create the preconditioner without arguments.
*/
void
- initialize(const MatrixBase & matrix,
+ initialize(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
protected:
* Constructor. Take the matrix which is used to form the preconditioner,
* and additional flags if there are any.
*/
- PreconditionLU(const MatrixBase & matrix,
+ PreconditionLU(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* used if you create the preconditioner without arguments.
*/
void
- initialize(const MatrixBase & matrix,
+ initialize(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
protected:
* and additional flags if there are any.
*/
PreconditionBoomerAMG(
- const MatrixBase & matrix,
+ const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* used if you create the preconditioner without arguments.
*/
void
- initialize(const MatrixBase & matrix,
+ initialize(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
protected:
* and additional flags if there are any.
*/
PreconditionParaSails(
- const MatrixBase & matrix,
+ const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* used if you create the preconditioner without arguments.
*/
void
- initialize(const MatrixBase & matrix,
+ initialize(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
private:
* and additional flags if there are any. The matrix is completely ignored
* in computations.
*/
- PreconditionNone(const MatrixBase & matrix,
+ PreconditionNone(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* completely ignored in computations.
*/
void
- initialize(const MatrixBase & matrix,
+ initialize(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
private:
* Constructor. Take the matrix which is used to form the preconditioner,
* and additional flags if there are any.
*/
- PreconditionBDDC(const MatrixBase & matrix,
+ PreconditionBDDC(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* used if you create the preconditioner without arguments.
*/
void
- initialize(const MatrixBase & matrix,
+ initialize(const MatrixBase &matrix,
const AdditionalData &additional_data = AdditionalData());
protected:
* See there for a description of how to deal with errors and other
* requirements and conventions.
*/
- std::function<void(const VectorType & x,
+ std::function<void(const VectorType &x,
const unsigned int step_number,
const real_type f_norm)>
monitor;
template <typename F, typename... Args>
int
call_and_possibly_capture_snes_exception(
- const F & f,
- std::exception_ptr & eptr,
+ const F &f,
+ std::exception_ptr &eptr,
const std::function<void()> &recoverable_action,
Args &&...args)
{
PetscObjectComm(reinterpret_cast<PetscObject>(snes)));
if (solve_with_jacobian)
{
- precond.vmult = [&](VectorBase & indst,
+ precond.vmult = [&](VectorBase &indst,
const VectorBase &insrc) -> void {
VectorType dst(static_cast<const Vec &>(indst));
const VectorType src(static_cast<const Vec &>(insrc));
Mat>)&&(concepts::is_dealii_petsc_matrix_type<AMatrixType> ||
std::constructible_from<AMatrixType, Mat>))
unsigned int NonlinearSolver<VectorType, PMatrixType, AMatrixType>::solve(
- VectorType & x,
+ VectorType &x,
PMatrixType &P)
{
set_matrix(P);
Mat>)&&(concepts::is_dealii_petsc_matrix_type<AMatrixType> ||
std::constructible_from<AMatrixType, Mat>))
unsigned int NonlinearSolver<VectorType, PMatrixType, AMatrixType>::solve(
- VectorType & x,
+ VectorType &x,
AMatrixType &A,
PMatrixType &P)
{
* performance reasons. See class Documentation.
*/
void
- solve(const MatrixBase & A,
- VectorBase & x,
- const VectorBase & b,
+ solve(const MatrixBase &A,
+ VectorBase &x,
+ const VectorBase &b,
const PreconditionBase &preconditioner);
/**
const PetscInt iteration,
const PetscReal residual_norm,
KSPConvergedReason *reason,
- void * solver_control);
+ void *solver_control);
# ifdef DEAL_II_WITH_SLEPC
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverRichardson(SolverControl & cn,
+ SolverRichardson(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverRichardson(SolverControl & cn,
+ SolverRichardson(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverChebychev(SolverControl & cn,
+ SolverChebychev(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverChebychev(SolverControl & cn,
+ SolverChebychev(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverCG(SolverControl & cn,
+ SolverCG(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverBiCG(SolverControl & cn,
+ SolverBiCG(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverBiCG(SolverControl & cn,
+ SolverBiCG(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverGMRES(SolverControl & cn,
+ SolverGMRES(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverGMRES(SolverControl & cn,
+ SolverGMRES(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverBicgstab(SolverControl & cn,
+ SolverBicgstab(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverBicgstab(SolverControl & cn,
+ SolverBicgstab(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverCGS(SolverControl & cn,
+ SolverCGS(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverTFQMR(SolverControl & cn,
+ SolverTFQMR(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverTFQMR(SolverControl & cn,
+ SolverTFQMR(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverTCQMR(SolverControl & cn,
+ SolverTCQMR(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverTCQMR(SolverControl & cn,
+ SolverTCQMR(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverCR(SolverControl & cn,
+ SolverCR(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverLSQR(SolverControl & cn,
+ SolverLSQR(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverLSQR(SolverControl & cn,
+ SolverLSQR(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverPreOnly(SolverControl & cn,
+ SolverPreOnly(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* @deprecated
*/
DEAL_II_DEPRECATED
- SolverPreOnly(SolverControl & cn,
+ SolverPreOnly(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
/**
* Constructor.
*/
- SparseDirectMUMPS(SolverControl & cn,
+ SparseDirectMUMPS(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* @deprecated
*/
DEAL_II_DEPRECATED
- SparseDirectMUMPS(SolverControl & cn,
+ SparseDirectMUMPS(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data = AdditionalData());
* This function calls MatrixBase::mmult() to do the actual work.
*/
void
- mmult(SparseMatrix & C,
+ mmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V = MPI::Vector()) const;
+ const MPI::Vector &V = MPI::Vector()) const;
/**
* Perform the matrix-matrix multiplication with the transpose of
* This function calls MatrixBase::Tmmult() to do the actual work.
*/
void
- Tmmult(SparseMatrix & C,
+ Tmmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V = MPI::Vector()) const;
+ const MPI::Vector &V = MPI::Vector()) const;
private:
/**
*/
template <typename SparsityPatternType>
SparseMatrix(const MPI_Comm communicator,
- const SparsityPatternType & sparsity_pattern,
+ const SparsityPatternType &sparsity_pattern,
const std::vector<size_type> &local_rows_per_process,
const std::vector<size_type> &local_columns_per_process,
const unsigned int this_process,
template <typename SparsityPatternType>
void
reinit(const MPI_Comm communicator,
- const SparsityPatternType & sparsity_pattern,
+ const SparsityPatternType &sparsity_pattern,
const std::vector<size_type> &local_rows_per_process,
const std::vector<size_type> &local_columns_per_process,
const unsigned int this_process,
*/
template <typename SparsityPatternType>
void
- reinit(const IndexSet & local_partitioning,
+ reinit(const IndexSet &local_partitioning,
const SparsityPatternType &sparsity_pattern,
const MPI_Comm communicator);
*/
template <typename SparsityPatternType>
void
- reinit(const IndexSet & local_rows,
- const IndexSet & local_columns,
+ reinit(const IndexSet &local_rows,
+ const IndexSet &local_columns,
const SparsityPatternType &sparsity_pattern,
const MPI_Comm communicator);
*/
template <typename SparsityPatternType>
void
- reinit(const IndexSet & local_rows,
- const IndexSet & local_active_rows,
- const IndexSet & local_columns,
- const IndexSet & local_active_columns,
+ reinit(const IndexSet &local_rows,
+ const IndexSet &local_active_rows,
+ const IndexSet &local_columns,
+ const IndexSet &local_active_columns,
const SparsityPatternType &sparsity_pattern,
const MPI_Comm communicator);
* This function calls MatrixBase::mmult() to do the actual work.
*/
void
- mmult(SparseMatrix & C,
+ mmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V = MPI::Vector()) const;
+ const MPI::Vector &V = MPI::Vector()) const;
/**
* Perform the matrix-matrix multiplication with the transpose of
* This function calls MatrixBase::Tmmult() to do the actual work.
*/
void
- Tmmult(SparseMatrix & C,
+ Tmmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V = MPI::Vector()) const;
+ const MPI::Vector &V = MPI::Vector()) const;
private:
/**
template <typename SparsityPatternType>
void
do_reinit(const MPI_Comm comm,
- const SparsityPatternType & sparsity_pattern,
+ const SparsityPatternType &sparsity_pattern,
const std::vector<size_type> &local_rows_per_process,
const std::vector<size_type> &local_columns_per_process,
const unsigned int this_process,
template <typename SparsityPatternType>
void
do_reinit(const MPI_Comm comm,
- const IndexSet & local_rows,
- const IndexSet & local_columns,
+ const IndexSet &local_rows,
+ const IndexSet &local_columns,
const SparsityPatternType &sparsity_pattern);
/**
template <typename SparsityPatternType>
void
do_reinit(const MPI_Comm comm,
- const IndexSet & local_rows,
- const IndexSet & local_active_rows,
- const IndexSet & local_columns,
- const IndexSet & local_active_columns,
+ const IndexSet &local_rows,
+ const IndexSet &local_active_rows,
+ const IndexSet &local_columns,
+ const IndexSet &local_active_columns,
const SparsityPatternType &sparsity_pattern);
// To allow calling protected prepare_add() and prepare_set().
typename AMatrixType = PMatrixType>
# if defined(DEAL_II_HAVE_CXX20) && \
!defined(DEAL_II_DOXYGEN_DO_NOT_PARSE_REQUIRES_CLAUSES)
- requires(
- (concepts::is_dealii_petsc_vector_type<VectorType> ||
- std::constructible_from<
- VectorType,
- Vec>)&&(concepts::is_dealii_petsc_matrix_type<PMatrixType> ||
- std::constructible_from<
- PMatrixType,
- Mat>)&&(concepts::is_dealii_petsc_matrix_type<AMatrixType> ||
- std::constructible_from<AMatrixType, Mat>))
+ requires((concepts::is_dealii_petsc_vector_type<VectorType> ||
+ std::constructible_from<VectorType, Vec>) &&
+ (concepts::is_dealii_petsc_matrix_type<PMatrixType> ||
+ std::constructible_from<PMatrixType, Mat>) &&
+ (concepts::is_dealii_petsc_matrix_type<AMatrixType> ||
+ std::constructible_from<AMatrixType, Mat>))
# endif
- class TimeStepper
+ class TimeStepper
{
public:
/**
std::function<void(const real_type t,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res)>
+ VectorType &res)>
implicit_function;
/**
const VectorType &y,
const VectorType &y_dot,
const real_type alpha,
- AMatrixType & A,
- PMatrixType & P)>
+ AMatrixType &A,
+ PMatrixType &P)>
implicit_jacobian;
/**
*/
std::function<void(const real_type t,
const VectorType &y,
- AMatrixType & A,
- PMatrixType & P)>
+ AMatrixType &A,
+ PMatrixType &P)>
explicit_jacobian;
/**
* requirements and conventions.
*/
std::function<void(const real_type t,
- const VectorType & y,
+ const VectorType &y,
const unsigned int step_number)>
monitor;
*/
std::function<void(const real_type t,
const unsigned int step,
- const VectorType & y,
- bool & resize)>
+ const VectorType &y,
+ bool &resize)>
decide_for_coarsening_and_refinement;
/**
* requirements and conventions.
*/
std::function<void(const std::vector<VectorType> &all_in,
- std::vector<VectorType> & all_out)>
+ std::vector<VectorType> &all_out)>
interpolate;
private:
template <typename F, typename... Args>
int
call_and_possibly_capture_ts_exception(
- const F & f,
- std::exception_ptr & eptr,
+ const F &f,
+ std::exception_ptr &eptr,
const std::function<void()> &recoverable_action,
Args &&...args)
{
PetscInt nv,
Vec vin[],
Vec vout[],
- void * ctx) -> PetscErrorCode {
+ void *ctx) -> PetscErrorCode {
PetscFunctionBeginUser;
auto user = static_cast<TimeStepper *>(ctx);
PetscReal s,
Mat A,
Mat P,
- void * ctx) -> PetscErrorCode {
+ void *ctx) -> PetscErrorCode {
PetscFunctionBeginUser;
auto user = static_cast<TimeStepper *>(ctx);
PetscReal s,
Mat A,
Mat P,
- void * ctx) -> PetscErrorCode {
+ void *ctx) -> PetscErrorCode {
PetscFunctionBeginUser;
auto user = static_cast<TimeStepper *>(ctx);
// approximation of the tangent operator.
if (solve_with_jacobian)
{
- solve_with_jacobian_pc.vmult = [&](VectorBase & indst,
+ solve_with_jacobian_pc.vmult = [&](VectorBase &indst,
const VectorBase &insrc) -> void {
VectorType dst(static_cast<const Vec &>(indst));
const VectorType src(static_cast<const Vec &>(insrc));
Mat>)&&(concepts::is_dealii_petsc_matrix_type<AMatrixType> ||
std::constructible_from<AMatrixType, Mat>))
unsigned int TimeStepper<VectorType, PMatrixType, AMatrixType>::solve(
- VectorType & y,
+ VectorType &y,
PMatrixType &P)
{
set_matrix(P);
Mat>)&&(concepts::is_dealii_petsc_matrix_type<AMatrixType> ||
std::constructible_from<AMatrixType, Mat>))
unsigned int TimeStepper<VectorType, PMatrixType, AMatrixType>::solve(
- VectorType & y,
+ VectorType &y,
AMatrixType &A,
PMatrixType &P)
{
* distributed across processors.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const bool across = true) const;
public:
template <typename Matrix>
static void
- reinit_range_vector(const Matrix & matrix,
+ reinit_range_vector(const Matrix &matrix,
PETScWrappers::MPI::Vector &v,
bool /*omit_zeroing_entries*/)
{
template <typename Matrix>
static void
- reinit_domain_vector(const Matrix & matrix,
+ reinit_domain_vector(const Matrix &matrix,
PETScWrappers::MPI::Vector &v,
bool /*omit_zeroing_entries*/)
{
* the corresponding values in the second.
*/
void
- set(const std::vector<size_type> & indices,
+ set(const std::vector<size_type> &indices,
const std::vector<PetscScalar> &values);
/**
*/
void
extract_subvector_to(const std::vector<size_type> &indices,
- std::vector<PetscScalar> & values) const;
+ std::vector<PetscScalar> &values) const;
/**
* Extract a range of elements all at once.
virtual void
extract_subvector_to(
const ArrayView<const types::global_dof_index> &indices,
- ArrayView<PetscScalar> & elements) const override;
+ ArrayView<PetscScalar> &elements) const override;
/**
* Instead of getting individual elements of a vector via operator(),
* stored in @p values to the vector components specified by @p indices.
*/
void
- add(const std::vector<size_type> & indices,
+ add(const std::vector<size_type> &indices,
const std::vector<PetscScalar> &values);
/**
* function takes a deal.II vector of values.
*/
void
- add(const std::vector<size_type> & indices,
+ add(const std::vector<size_type> &indices,
const ::dealii::Vector<PetscScalar> &values);
/**
*/
void
add(const size_type n_elements,
- const size_type * indices,
+ const size_type *indices,
const PetscScalar *values);
/**
* separate line each.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const bool across = true) const;
*/
void
do_set_add_operation(const size_type n_elements,
- const size_type * indices,
+ const size_type *indices,
const PetscScalar *values,
const bool add_values);
inline void
VectorBase::extract_subvector_to(const std::vector<size_type> &indices,
- std::vector<PetscScalar> & values) const
+ std::vector<PetscScalar> &values) const
{
Assert(indices.size() <= values.size(),
ExcDimensionMismatch(indices.size(), values.size()));
inline void
VectorBase::extract_subvector_to(
const ArrayView<const types::global_dof_index> &indices,
- ArrayView<PetscScalar> & elements) const
+ ArrayView<PetscScalar> &elements) const
{
AssertDimension(indices.size(), elements.size());
extract_subvector_to(indices.begin(), indices.end(), elements.begin());
*/
template <typename MatrixType>
void
- initialize(const MatrixType & matrix,
+ initialize(const MatrixType &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* zero and smaller than 2 for numerical reasons. It defaults to 1.
*/
void
- initialize(const MatrixType & A,
+ initialize(const MatrixType &A,
const AdditionalData ¶meters = AdditionalData());
/**
typename PreconditionerType>
constexpr bool has_vmult_with_std_functions =
is_supported_operation<vmult_functions_t, MatrixType, VectorType> &&
- std::is_same_v<PreconditionerType, dealii::DiagonalMatrix<VectorType>> &&
+ std::is_same_v<PreconditionerType, dealii::DiagonalMatrix<VectorType>> &&
(std::is_same_v<VectorType,
dealii::Vector<typename VectorType::value_type>> ||
std::is_same_v<
namespace PreconditionRelaxation
{
template <typename T, typename VectorType>
- using Tvmult_t = decltype(
- std::declval<const T>().Tvmult(std::declval<VectorType &>(),
- std::declval<const VectorType &>()));
+ using Tvmult_t = decltype(std::declval<const T>().Tvmult(
+ std::declval<VectorType &>(),
+ std::declval<const VectorType &>()));
template <typename T, typename VectorType>
constexpr bool has_Tvmult = is_supported_operation<Tvmult_t, T, VectorType>;
template <typename T, typename VectorType>
- using step_t = decltype(
- std::declval<const T>().step(std::declval<VectorType &>(),
- std::declval<const VectorType &>()));
+ using step_t = decltype(std::declval<const T>().step(
+ std::declval<VectorType &>(),
+ std::declval<const VectorType &>()));
template <typename T, typename VectorType>
constexpr bool has_step = is_supported_operation<step_t, T, VectorType>;
is_supported_operation<step_omega_t, T, VectorType>;
template <typename T, typename VectorType>
- using Tstep_t = decltype(
- std::declval<const T>().Tstep(std::declval<VectorType &>(),
- std::declval<const VectorType &>()));
+ using Tstep_t = decltype(std::declval<const T>().Tstep(
+ std::declval<VectorType &>(),
+ std::declval<const VectorType &>()));
template <typename T, typename VectorType>
constexpr bool has_Tstep = is_supported_operation<Tstep_t, T, VectorType>;
is_supported_operation<Tstep_omega_t, T, VectorType>;
template <typename T, typename VectorType>
- using jacobi_step_t = decltype(
- std::declval<const T>().Jacobi_step(std::declval<VectorType &>(),
- std::declval<const VectorType &>(),
- std::declval<const double>()));
+ using jacobi_step_t = decltype(std::declval<const T>().Jacobi_step(
+ std::declval<VectorType &>(),
+ std::declval<const VectorType &>(),
+ std::declval<const double>()));
template <typename T, typename VectorType>
constexpr bool has_jacobi_step =
is_supported_operation<jacobi_step_t, T, VectorType>;
template <typename T, typename VectorType>
- using SOR_step_t = decltype(
- std::declval<const T>().SOR_step(std::declval<VectorType &>(),
- std::declval<const VectorType &>(),
- std::declval<const double>()));
+ using SOR_step_t = decltype(std::declval<const T>().SOR_step(
+ std::declval<VectorType &>(),
+ std::declval<const VectorType &>(),
+ std::declval<const double>()));
template <typename T, typename VectorType>
constexpr bool has_SOR_step =
is_supported_operation<SOR_step_t, T, VectorType>;
template <typename T, typename VectorType>
- using SSOR_step_t = decltype(
- std::declval<const T>().SSOR_step(std::declval<VectorType &>(),
- std::declval<const VectorType &>(),
- std::declval<const double>()));
+ using SSOR_step_t = decltype(std::declval<const T>().SSOR_step(
+ std::declval<VectorType &>(),
+ std::declval<const VectorType &>(),
+ std::declval<const double>()));
template <typename T, typename VectorType>
constexpr bool has_SSOR_step =
public:
using size_type = typename MatrixType::size_type;
- PreconditionPSORImpl(const MatrixType & A,
+ PreconditionPSORImpl(const MatrixType &A,
const double relaxation,
const std::vector<size_type> &permutation,
const std::vector<size_type> &inverse_permutation)
void
step(const MatrixType &,
const PreconditionerType &preconditioner,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const double relaxation,
VectorType &,
VectorType &)
void
step(const MatrixType &,
const PreconditionerType &preconditioner,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const double relaxation,
VectorType &,
VectorType &)
!has_step<PreconditionerType, VectorType>,
PreconditionerType> * = nullptr>
void
- step(const MatrixType & A,
+ step(const MatrixType &A,
const PreconditionerType &preconditioner,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const double relaxation,
- VectorType & residual,
- VectorType & tmp)
+ VectorType &residual,
+ VectorType &tmp)
{
residual.reinit(dst, true);
tmp.reinit(dst, true);
void
Tstep(const MatrixType &,
const PreconditionerType &preconditioner,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const double relaxation,
VectorType &,
VectorType &)
void
Tstep(const MatrixType &,
const PreconditionerType &preconditioner,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const double relaxation,
VectorType &,
VectorType &)
!has_Tstep<PreconditionerType, VectorType>,
PreconditionerType> * = nullptr>
void
- Tstep(const MatrixType & A,
+ Tstep(const MatrixType &A,
const PreconditionerType &preconditioner,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const double relaxation,
- VectorType & residual,
- VectorType & tmp)
+ VectorType &residual,
+ VectorType &tmp)
{
residual.reinit(dst, true);
tmp.reinit(dst, true);
VectorType>,
int> * = nullptr>
void
- step_operations(const MatrixType & A,
+ step_operations(const MatrixType &A,
const PreconditionerType &preconditioner,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const double relaxation,
- VectorType & tmp1,
- VectorType & tmp2,
+ VectorType &tmp1,
+ VectorType &tmp2,
const unsigned int i,
const bool transposed)
{
VectorType>,
int> * = nullptr>
void
- step_operations(const MatrixType & A,
+ step_operations(const MatrixType &A,
const PreconditionerType &preconditioner,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const double relaxation,
- VectorType & tmp,
+ VectorType &tmp,
VectorType &,
const unsigned int i,
const bool transposed)
if (i == 0)
{
- Number * dst_ptr = dst.begin();
+ Number *dst_ptr = dst.begin();
const Number *src_ptr = src.begin();
preconditioner.vmult(
has_vmult_with_std_functions_for_precondition<MatrixType, VectorType>,
int> * = nullptr>
void
- step_operations(const MatrixType & A,
+ step_operations(const MatrixType &A,
const PreconditionerType &preconditioner,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const double relaxation,
- VectorType & tmp,
+ VectorType &tmp,
VectorType &,
const unsigned int i,
const bool transposed)
if (i == 0)
{
- Number * dst_ptr = dst.begin();
+ Number *dst_ptr = dst.begin();
const Number *src_ptr = src.begin();
preconditioner.vmult(
dealii::DiagonalMatrix<VectorType>>,
VectorType> * = nullptr>
void
- step_operations(const MatrixType & A,
+ step_operations(const MatrixType &A,
const dealii::DiagonalMatrix<VectorType> &preconditioner,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const double relaxation,
- VectorType & tmp,
+ VectorType &tmp,
VectorType &,
const unsigned int i,
const bool transposed)
if (i == 0)
{
- Number * dst_ptr = dst.begin();
+ Number *dst_ptr = dst.begin();
const Number *src_ptr = src.begin();
const Number *diag_ptr = preconditioner.get_vector().begin();
{
tmp.reinit(src, true);
- Number * dst_ptr = dst.begin();
+ Number *dst_ptr = dst.begin();
const Number *src_ptr = src.begin();
const Number *tmp_ptr = tmp.begin();
const Number *diag_ptr = preconditioner.get_vector().begin();
dealii::DiagonalMatrix<VectorType>>,
VectorType> * = nullptr>
void
- step_operations(const MatrixType & A,
+ step_operations(const MatrixType &A,
const dealii::DiagonalMatrix<VectorType> &preconditioner,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const double relaxation,
- VectorType & tmp,
+ VectorType &tmp,
VectorType &,
const unsigned int i,
const bool transposed)
if (i == 0)
{
- Number * dst_ptr = dst.begin();
+ Number *dst_ptr = dst.begin();
const Number *src_ptr = src.begin();
const Number *diag_ptr = preconditioner.get_vector().begin();
[&](const unsigned int begin, const unsigned int end) {
const Number *dst_ptr = dst.begin();
const Number *src_ptr = src.begin();
- Number * tmp_ptr = tmp.begin();
+ Number *tmp_ptr = tmp.begin();
const Number *diag_ptr = preconditioner.get_vector().begin();
// for efficiency reason, write back to temp_vector that is
* @copydoc PreconditionRelaxation::initialize()
*/
void
- initialize(const MatrixType & A,
+ initialize(const MatrixType &A,
const AdditionalData ¶meters = AdditionalData());
};
* @copydoc PreconditionRelaxation::initialize()
*/
void
- initialize(const MatrixType & A,
+ initialize(const MatrixType &A,
const AdditionalData ¶meters = AdditionalData());
};
* zero and smaller than 2 for numerical reasons. It defaults to 1.
*/
void
- initialize(const MatrixType & A,
+ initialize(const MatrixType &A,
const AdditionalData ¶meters = AdditionalData());
};
* for numerical reasons. It defaults to 1.
*/
void
- initialize(const MatrixType & A,
- const std::vector<size_type> & permutation,
- const std::vector<size_type> & inverse_permutation,
+ initialize(const MatrixType &A,
+ const std::vector<size_type> &permutation,
+ const std::vector<size_type> &inverse_permutation,
const typename BaseClass::AdditionalData ¶meters =
typename BaseClass::AdditionalData());
* given number of iterations is positive.
*/
void
- initialize(const MatrixType & matrix,
+ initialize(const MatrixType &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
template <typename MatrixType>
inline void
PreconditionRichardson::initialize(
- const MatrixType & matrix,
+ const MatrixType &matrix,
const PreconditionRichardson::AdditionalData ¶meters)
{
relaxation = parameters.relaxation;
template <typename MatrixType, typename PreconditionerType>
inline void
PreconditionRelaxation<MatrixType, PreconditionerType>::initialize(
- const MatrixType & rA,
+ const MatrixType &rA,
const AdditionalData ¶meters)
{
A = &rA;
template <typename VectorType>
inline void
PreconditionRelaxation<MatrixType, PreconditionerType>::vmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
Assert(this->A != nullptr, ExcNotInitialized());
template <typename VectorType>
inline void
PreconditionRelaxation<MatrixType, PreconditionerType>::Tvmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
Assert(this->A != nullptr, ExcNotInitialized());
template <typename VectorType>
inline void
PreconditionRelaxation<MatrixType, PreconditionerType>::step(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
Assert(this->A != nullptr, ExcNotInitialized());
template <typename VectorType>
inline void
PreconditionRelaxation<MatrixType, PreconditionerType>::Tstep(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
Assert(this->A != nullptr, ExcNotInitialized());
template <typename MatrixType>
inline void
-PreconditionJacobi<MatrixType>::initialize(const MatrixType & A,
+PreconditionJacobi<MatrixType>::initialize(const MatrixType &A,
const AdditionalData ¶meters_in)
{
Assert(parameters_in.preconditioner == nullptr, ExcInternalError());
template <typename MatrixType>
inline void
-PreconditionSOR<MatrixType>::initialize(const MatrixType & A,
+PreconditionSOR<MatrixType>::initialize(const MatrixType &A,
const AdditionalData ¶meters_in)
{
Assert(parameters_in.preconditioner == nullptr, ExcInternalError());
template <typename MatrixType>
inline void
-PreconditionSSOR<MatrixType>::initialize(const MatrixType & A,
+PreconditionSSOR<MatrixType>::initialize(const MatrixType &A,
const AdditionalData ¶meters_in)
{
Assert(parameters_in.preconditioner == nullptr, ExcInternalError());
template <typename MatrixType>
inline void
PreconditionPSOR<MatrixType>::initialize(
- const MatrixType & A,
- const std::vector<size_type> & p,
- const std::vector<size_type> & ip,
+ const MatrixType &A,
+ const std::vector<size_type> &p,
+ const std::vector<size_type> &ip,
const typename BaseClass::AdditionalData ¶meters_in)
{
Assert(parameters_in.preconditioner == nullptr, ExcInternalError());
template <typename MatrixType>
inline void
-PreconditionPSOR<MatrixType>::initialize(const MatrixType & A,
+PreconditionPSOR<MatrixType>::initialize(const MatrixType &A,
const AdditionalData &additional_data)
{
initialize(A,
template <typename MatrixType, typename VectorType>
PreconditionUseMatrix<MatrixType, VectorType>::PreconditionUseMatrix(
- const MatrixType & M,
+ const MatrixType &M,
const function_ptr method)
: matrix(M)
, precondition(method)
template <typename MatrixType, typename VectorType>
void
PreconditionUseMatrix<MatrixType, VectorType>::vmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
(matrix.*precondition)(dst, src);
// generic part for non-deal.II vectors
template <typename VectorType, typename PreconditionerType>
inline void
- vector_updates(const VectorType & rhs,
+ vector_updates(const VectorType &rhs,
const PreconditionerType &preconditioner,
const unsigned int iteration_index,
const double factor1,
const double factor2,
- VectorType & solution_old,
- VectorType & temp_vector1,
- VectorType & temp_vector2,
- VectorType & solution)
+ VectorType &solution_old,
+ VectorType &temp_vector1,
+ VectorType &temp_vector2,
+ VectorType &solution)
{
if (iteration_index == 0)
{
template <typename Number>
struct VectorUpdater
{
- VectorUpdater(const Number * rhs,
- const Number * matrix_diagonal_inverse,
+ VectorUpdater(const Number *rhs,
+ const Number *matrix_diagonal_inverse,
const unsigned int iteration_index,
const Number factor1,
const Number factor2,
- Number * solution_old,
- Number * tmp_vector,
- Number * solution)
+ Number *solution_old,
+ Number *tmp_vector,
+ Number *solution)
: rhs(rhs)
, matrix_diagonal_inverse(matrix_diagonal_inverse)
, iteration_index(iteration_index)
}
}
- const Number * rhs;
- const Number * matrix_diagonal_inverse;
+ const Number *rhs;
+ const Number *matrix_diagonal_inverse;
const unsigned int iteration_index;
const Number factor1;
const Number factor2;
- mutable Number * solution_old;
- mutable Number * tmp_vector;
- mutable Number * solution;
+ mutable Number *solution_old;
+ mutable Number *tmp_vector;
+ mutable Number *solution;
};
template <typename Number>
template <typename Number>
inline void
vector_updates(
- const ::dealii::Vector<Number> & rhs,
+ const ::dealii::Vector<Number> &rhs,
const dealii::DiagonalMatrix<::dealii::Vector<Number>> &jacobi,
const unsigned int iteration_index,
const double factor1,
const double factor2,
- ::dealii::Vector<Number> & solution_old,
- ::dealii::Vector<Number> & temp_vector1,
+ ::dealii::Vector<Number> &solution_old,
+ ::dealii::Vector<Number> &temp_vector1,
::dealii::Vector<Number> &,
::dealii::Vector<Number> &solution)
{
VectorType>),
int> * = nullptr>
inline void
- vmult_and_update(const MatrixType & matrix,
+ vmult_and_update(const MatrixType &matrix,
const PreconditionerType &preconditioner,
- const VectorType & rhs,
+ const VectorType &rhs,
const unsigned int iteration_index,
const double factor1,
const double factor2,
- VectorType & solution,
- VectorType & solution_old,
- VectorType & temp_vector1,
- VectorType & temp_vector2)
+ VectorType &solution,
+ VectorType &solution_old,
+ VectorType &temp_vector1,
+ VectorType &temp_vector2)
{
if (iteration_index > 0)
matrix.vmult(temp_vector1, solution);
VectorType>),
int> * = nullptr>
inline void
- vmult_and_update(const MatrixType & matrix,
+ vmult_and_update(const MatrixType &matrix,
const PreconditionerType &preconditioner,
- const VectorType & rhs,
+ const VectorType &rhs,
const unsigned int iteration_index,
const double factor1_,
const double factor2_,
- VectorType & solution,
- VectorType & solution_old,
- VectorType & temp_vector1,
- VectorType & temp_vector2)
+ VectorType &solution,
+ VectorType &solution_old,
+ VectorType &temp_vector1,
+ VectorType &temp_vector2)
{
using Number = typename VectorType::value_type;
PreconditionerType>,
int> * = nullptr>
inline void
- vmult_and_update(const MatrixType & matrix,
+ vmult_and_update(const MatrixType &matrix,
const PreconditionerType &preconditioner,
- const VectorType & rhs,
+ const VectorType &rhs,
const unsigned int iteration_index,
const double factor1,
const double factor2,
- VectorType & solution,
- VectorType & solution_old,
- VectorType & temp_vector1,
+ VectorType &solution,
+ VectorType &solution_old,
+ VectorType &temp_vector1,
VectorType &)
{
using Number = typename VectorType::value_type;
template <typename MatrixType, typename PreconditionerType>
inline void
initialize_preconditioner(
- const MatrixType & matrix,
+ const MatrixType &matrix,
std::shared_ptr<PreconditionerType> &preconditioner)
{
(void)matrix;
template <typename MatrixType, typename VectorType>
inline void
initialize_preconditioner(
- const MatrixType & matrix,
+ const MatrixType &matrix,
std::shared_ptr<dealii::DiagonalMatrix<VectorType>> &preconditioner)
{
if (preconditioner.get() == nullptr || preconditioner->m() != matrix.m())
first_local_range = vector.locally_owned_elements().nth_index_in_set(0);
const auto n_local_elements = vector.locally_owned_size();
- Number * values_ptr = vector.get_values();
+ Number *values_ptr = vector.get_values();
Kokkos::RangePolicy<typename MemorySpace::kokkos_space::execution_space,
Kokkos::IndexType<types::global_dof_index>>
policy(0, n_local_elements);
typename VectorType,
typename PreconditionerType>
double
- power_iteration(const MatrixType & matrix,
- VectorType & eigenvector,
+ power_iteration(const MatrixType &matrix,
+ VectorType &eigenvector,
const PreconditionerType &preconditioner,
const unsigned int n_iterations)
{
template <typename MatrixType, typename VectorType, typename PreconditionerType>
inline void
PreconditionChebyshev<MatrixType, VectorType, PreconditionerType>::initialize(
- const MatrixType & matrix,
+ const MatrixType &matrix,
const AdditionalData &additional_data)
{
matrix_ptr = &matrix;
template <typename MatrixType, typename VectorType, typename PreconditionerType>
inline void
PreconditionChebyshev<MatrixType, VectorType, PreconditionerType>::vmult(
- VectorType & solution,
+ VectorType &solution,
const VectorType &rhs) const
{
std::lock_guard<std::mutex> lock(mutex);
template <typename MatrixType, typename VectorType, typename PreconditionerType>
inline void
PreconditionChebyshev<MatrixType, VectorType, PreconditionerType>::Tvmult(
- VectorType & solution,
+ VectorType &solution,
const VectorType &rhs) const
{
std::lock_guard<std::mutex> lock(mutex);
template <typename MatrixType, typename VectorType, typename PreconditionerType>
inline void
PreconditionChebyshev<MatrixType, VectorType, PreconditionerType>::step(
- VectorType & solution,
+ VectorType &solution,
const VectorType &rhs) const
{
std::lock_guard<std::mutex> lock(mutex);
template <typename MatrixType, typename VectorType, typename PreconditionerType>
inline void
PreconditionChebyshev<MatrixType, VectorType, PreconditionerType>::Tstep(
- VectorType & solution,
+ VectorType &solution,
const VectorType &rhs) const
{
std::lock_guard<std::mutex> lock(mutex);
* Additionally, a relaxation parameter for derived classes may be provided.
*/
void
- initialize(const MatrixType & A,
+ initialize(const MatrixType &A,
const std::vector<size_type> &permutation,
const std::vector<size_type> &inverse_permutation,
const AdditionalData parameters);
*/
template <typename number2>
void
- forward_step(Vector<number2> & dst,
+ forward_step(Vector<number2> &dst,
const Vector<number2> &prev,
const Vector<number2> &src,
const bool transpose_diagonal) const;
*/
template <typename number2>
void
- backward_step(Vector<number2> & dst,
+ backward_step(Vector<number2> &dst,
const Vector<number2> &prev,
const Vector<number2> &src,
const bool transpose_diagonal) const;
template <typename MatrixType, typename inverse_type>
void
PreconditionBlock<MatrixType, inverse_type>::initialize(
- const MatrixType & M,
+ const MatrixType &M,
const AdditionalData parameters)
{
const size_type bsize = parameters.block_size;
template <typename MatrixType, typename inverse_type>
void
PreconditionBlock<MatrixType, inverse_type>::initialize(
- const MatrixType & M,
+ const MatrixType &M,
const std::vector<size_type> &new_permutation,
const std::vector<size_type> &new_inverse_permutation,
const AdditionalData parameters)
template <typename number2>
void
PreconditionBlock<MatrixType, inverse_type>::forward_step(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &prev,
const Vector<number2> &src,
const bool transpose_diagonal) const
template <typename number2>
void
PreconditionBlock<MatrixType, inverse_type>::backward_step(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &prev,
const Vector<number2> &src,
const bool transpose_diagonal) const
template <typename number2>
void
PreconditionBlockJacobi<MatrixType, inverse_type>::do_vmult(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src,
bool adding) const
{
template <typename number2>
void
PreconditionBlockJacobi<MatrixType, inverse_type>::vmult(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
do_vmult(dst, src, false);
template <typename number2>
void
PreconditionBlockJacobi<MatrixType, inverse_type>::Tvmult(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
do_vmult(dst, src, false);
template <typename number2>
void
PreconditionBlockJacobi<MatrixType, inverse_type>::vmult_add(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
do_vmult(dst, src, true);
template <typename number2>
void
PreconditionBlockJacobi<MatrixType, inverse_type>::Tvmult_add(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
do_vmult(dst, src, true);
template <typename number2>
void
PreconditionBlockJacobi<MatrixType, inverse_type>::step(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
GrowingVectorMemory<Vector<number2>> mem;
template <typename number2>
void
PreconditionBlockJacobi<MatrixType, inverse_type>::Tstep(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
GrowingVectorMemory<Vector<number2>> mem;
template <typename number2>
void
PreconditionBlockSOR<MatrixType, inverse_type>::forward(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src,
const bool transpose_diagonal,
const bool) const
template <typename number2>
void
PreconditionBlockSOR<MatrixType, inverse_type>::backward(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src,
const bool transpose_diagonal,
const bool) const
template <typename number2>
void
PreconditionBlockSOR<MatrixType, inverse_type>::vmult(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
forward(dst, src, false, false);
template <typename number2>
void
PreconditionBlockSOR<MatrixType, inverse_type>::vmult_add(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
forward(dst, src, false, true);
template <typename number2>
void
PreconditionBlockSOR<MatrixType, inverse_type>::Tvmult(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
backward(dst, src, true, false);
template <typename number2>
void
PreconditionBlockSOR<MatrixType, inverse_type>::Tvmult_add(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
backward(dst, src, true, true);
template <typename number2>
void
PreconditionBlockSOR<MatrixType, inverse_type>::step(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
this->forward_step(dst, dst, src, false);
template <typename number2>
void
PreconditionBlockSOR<MatrixType, inverse_type>::Tstep(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
this->backward_step(dst, dst, src, true);
template <typename number2>
void
PreconditionBlockSSOR<MatrixType, inverse_type>::vmult(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
Vector<number2> help;
template <typename number2>
void
PreconditionBlockSSOR<MatrixType, inverse_type>::Tvmult(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
Vector<number2> help;
template <typename number2>
void
PreconditionBlockSSOR<MatrixType, inverse_type>::step(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
this->forward_step(dst, dst, src, false);
template <typename number2>
void
PreconditionBlockSSOR<MatrixType, inverse_type>::Tstep(
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
this->backward_step(dst, dst, src, true);
template <typename number2>
void
inverse_vmult(size_type i,
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const;
/**
template <typename number2>
void
inverse_Tvmult(size_type i,
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const;
/**
template <typename number2>
inline void
PreconditionBlockBase<number>::inverse_vmult(size_type i,
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
const size_type ii = same_diagonal() ? 0U : i;
template <typename number2>
inline void
PreconditionBlockBase<number>::inverse_Tvmult(size_type i,
- Vector<number2> & dst,
+ Vector<number2> &dst,
const Vector<number2> &src) const
{
const size_type ii = same_diagonal() ? 0U : i;
<< ']' << std::endl;
}
else if (inversion == householder)
- {}
+ {
+ }
else if (inversion == gauss_jordan)
- {}
+ {
+ }
else
{
Assert(false, ExcNotImplemented());
* Constructor. @p omega denotes the damping parameter of the
* preconditioning.
*/
- PreconditionSelector(const std::string & preconditioning,
+ PreconditionSelector(const std::string &preconditioning,
const typename VectorType::value_type &omega = 1.);
/**
template <typename MatrixType, typename VectorType>
PreconditionSelector<MatrixType, VectorType>::PreconditionSelector(
- const std::string & preconditioning,
+ const std::string &preconditioning,
const typename VectorType::value_type &omega)
: preconditioning(preconditioning)
, omega(omega)
template <typename MatrixType, typename VectorType>
void
-PreconditionSelector<MatrixType, VectorType>::vmult(VectorType & dst,
+PreconditionSelector<MatrixType, VectorType>::vmult(VectorType &dst,
const VectorType &src) const
{
if (preconditioning == "none")
template <typename MatrixType, typename VectorType>
void
PreconditionSelector<MatrixType, VectorType>::Tvmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
if (preconditioning == "none")
* If @p transpose is <code>true</code>, $R^Tx=y$ is solved instead.
*/
void
- solve(Vector<Number> & x,
+ solve(Vector<Number> &x,
const Vector<Number> &y,
const bool transpose = false) const;
boost::signals2::connection
connect_append_column_slot(
const std::function<bool(const Vector<Number> &u,
- const Number & rho2,
- const Number & col_norm_sqr)> &slot);
+ const Number &rho2,
+ const Number &col_norm_sqr)> &slot);
private:
/**
* linearly independent.
*/
boost::signals2::signal<bool(const Vector<Number> &u,
- const Number & rho,
- const Number & col_norm_sqr)>
+ const Number &rho,
+ const Number &col_norm_sqr)>
column_signal;
};
const char trans,
const char diag,
const types::blas_int n,
- const Number * a,
+ const Number *a,
const types::blas_int lda,
- Number * x,
+ Number *x,
const types::blas_int incx);
template <typename Number>
const char diag,
const types::blas_int n,
const types::blas_int nrhs,
- const Number * a,
+ const Number *a,
const types::blas_int lda,
- Number * b,
+ Number *b,
const types::blas_int ldb,
- types::blas_int * info);
+ types::blas_int *info);
} // namespace QRImplementation
} // namespace internal
template <typename VectorType>
void
-BaseQR<VectorType>::solve(Vector<Number> & x,
+BaseQR<VectorType>::solve(Vector<Number> &x,
const Vector<Number> &y,
const bool transpose) const
{
template <typename VectorType>
void
-BaseQR<VectorType>::multiply_with_cols(VectorType & y,
+BaseQR<VectorType>::multiply_with_cols(VectorType &y,
const Vector<Number> &x) const
{
Assert(x.size() == this->current_size,
template <typename VectorType>
void
-BaseQR<VectorType>::multiply_with_colsT(Vector<Number> & y,
+BaseQR<VectorType>::multiply_with_colsT(Vector<Number> &y,
const VectorType &x) const
{
Assert(y.size() == this->current_size,
boost::signals2::connection
ImplicitQR<VectorType>::connect_append_column_slot(
const std::function<bool(const Vector<Number> &u,
- const Number & rho,
- const Number & col_norm_sqr)> &slot)
+ const Number &rho,
+ const Number &col_norm_sqr)> &slot)
{
return column_signal.connect(slot);
}
template <typename VectorType>
void
-ImplicitQR<VectorType>::multiply_with_Q(VectorType & y,
+ImplicitQR<VectorType>::multiply_with_Q(VectorType &y,
const Vector<Number> &x) const
{
// A = QR
template <typename VectorType>
void
-ImplicitQR<VectorType>::multiply_with_QT(Vector<Number> & y,
+ImplicitQR<VectorType>::multiply_with_QT(Vector<Number> &y,
const VectorType &x) const
{
// A = QR
template <typename VectorType>
void
-ImplicitQR<VectorType>::multiply_with_A(VectorType & y,
+ImplicitQR<VectorType>::multiply_with_A(VectorType &y,
const Vector<Number> &x) const
{
BaseQR<VectorType>::multiply_with_cols(y, x);
template <typename VectorType>
void
-ImplicitQR<VectorType>::multiply_with_AT(Vector<Number> & y,
+ImplicitQR<VectorType>::multiply_with_AT(Vector<Number> &y,
const VectorType &x) const
{
BaseQR<VectorType>::multiply_with_colsT(y, x);
template <typename Number2>
void
extract_subvector_to(const std::vector<size_type> &indices,
- std::vector<Number2> & values) const;
+ std::vector<Number2> &values) const;
/**
* Extract a range of elements all at once.
virtual void
extract_subvector_to(
const ArrayView<const types::global_dof_index> &indices,
- ArrayView<Number> & entries) const override;
+ ArrayView<Number> &entries) const override;
/**
* Instead of getting individual elements of a vector via operator(),
template <typename Number2>
void
add(const std::vector<size_type> &indices,
- const std::vector<Number2> & values);
+ const std::vector<Number2> &values);
/**
* This function is similar to the previous one but takes a
*/
template <typename Number2>
void
- add(const std::vector<size_type> & indices,
+ add(const std::vector<size_type> &indices,
const ReadWriteVector<Number2> &values);
/**
void
add(const size_type n_elements,
const size_type *indices,
- const Number2 * values);
+ const Number2 *values);
/**
* Prints the vector to the output stream @p out.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true) const;
dealii::is_tpetra_type<Number>::value>
import_elements(
const Tpetra::Vector<Number, int, types::signed_global_dof_index>
- & tpetra_vector,
- const IndexSet & locally_owned_elements,
+ &tpetra_vector,
+ const IndexSet &locally_owned_elements,
VectorOperation::values operation,
const MPI_Comm mpi_comm,
const std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
void
import_elements(
const Epetra_MultiVector &multivector,
- const IndexSet & locally_owned_elements,
+ const IndexSet &locally_owned_elements,
VectorOperation::values operation,
const MPI_Comm mpi_comm,
const std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
inline void
ReadWriteVector<Number>::extract_subvector_to(
const std::vector<size_type> &indices,
- std::vector<Number2> & extracted_values) const
+ std::vector<Number2> &extracted_values) const
{
for (size_type i = 0; i < indices.size(); ++i)
extracted_values[i] = operator()(indices[i]);
void
ReadWriteVector<Number>::extract_subvector_to(
const ArrayView<const types::global_dof_index> &indices,
- ArrayView<Number> & entries) const
+ ArrayView<Number> &entries) const
{
AssertDimension(indices.size(), entries.size());
for (unsigned int i = 0; i < indices.size(); ++i)
template <typename Number2>
inline void
ReadWriteVector<Number>::add(const std::vector<size_type> &indices,
- const std::vector<Number2> & values)
+ const std::vector<Number2> &values)
{
AssertDimension(indices.size(), values.size());
add(indices.size(), indices.data(), values.data());
template <typename Number>
template <typename Number2>
inline void
- ReadWriteVector<Number>::add(const std::vector<size_type> & indices,
+ ReadWriteVector<Number>::add(const std::vector<size_type> &indices,
const ReadWriteVector<Number2> &values)
{
const size_type size = indices.size();
inline void
ReadWriteVector<Number>::add(const size_type n_indices,
const size_type *indices,
- const Number2 * values_to_add)
+ const Number2 *values_to_add)
{
for (size_type i = 0; i < n_indices; ++i)
{
template <typename Functor>
inline ReadWriteVector<Number>::FunctorTemplate<Functor>::FunctorTemplate(
ReadWriteVector<Number> &parent,
- const Functor & functor)
+ const Functor &functor)
: parent(parent)
, functor(functor)
{}
static void
import_elements(
const std::shared_ptr<const ::dealii::Utilities::MPI::Partitioner>
- & communication_pattern,
- const Number * values,
+ &communication_pattern,
+ const Number *values,
const VectorOperation::values operation,
::dealii::LinearAlgebra::ReadWriteVector<Number> &rw_vector)
{
static void
import_elements(
const std::shared_ptr<const ::dealii::Utilities::MPI::Partitioner>
- & communication_pattern,
- const Number * values,
+ &communication_pattern,
+ const Number *values,
const VectorOperation::values operation,
::dealii::LinearAlgebra::ReadWriteVector<Number> &rw_vector)
{
static void
import_elements(
const std::shared_ptr<const ::dealii::Utilities::MPI::Partitioner>
- & communication_pattern,
- const Number * values,
+ &communication_pattern,
+ const Number *values,
const VectorOperation::values operation,
::dealii::LinearAlgebra::ReadWriteVector<Number> &rw_vector)
{
{
template <typename VectorType, typename Number>
void
- import_serial_vector(const VectorType & values,
+ import_serial_vector(const VectorType &values,
VectorOperation::values operation,
ReadWriteVector<Number> &rw_vector)
{
void
copy_petsc_vector(const PETSC_Number *petsc_start_ptr,
const PETSC_Number *petsc_end_ptr,
- Number * ptr)
+ Number *ptr)
{
std::copy(petsc_start_ptr, petsc_end_ptr, ptr);
}
void
copy_petsc_vector(const std::complex<PETSC_Number> *petsc_start_ptr,
const std::complex<PETSC_Number> *petsc_end_ptr,
- std::complex<Number> * ptr)
+ std::complex<Number> *ptr)
{
std::copy(petsc_start_ptr, petsc_end_ptr, ptr);
}
dealii::is_tpetra_type<Number>::value>
ReadWriteVector<Number>::import_elements(
const Tpetra::Vector<Number, int, types::signed_global_dof_index> &vector,
- const IndexSet & source_elements,
+ const IndexSet &source_elements,
VectorOperation::values operation,
const MPI_Comm mpi_comm,
const std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
void
ReadWriteVector<Number>::import_elements(
const Epetra_MultiVector &multivector,
- const IndexSet & source_elements,
+ const IndexSet &source_elements,
VectorOperation::values operation,
const MPI_Comm mpi_comm,
const std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
template <typename Number>
void
- ReadWriteVector<Number>::print(std::ostream & out,
+ ReadWriteVector<Number>::print(std::ostream &out,
const unsigned int precision,
const bool scientific) const
{
const typename PreconditionBlockBase<InverseNumberType>::Inversion
inversion = PreconditionBlockBase<InverseNumberType>::gauss_jordan,
const double threshold = 0.,
- VectorType * temp_ghost_vector = nullptr);
+ VectorType *temp_ghost_vector = nullptr);
/**
* The mapping from indices to blocks. Each row of this pattern enumerates
* @p prev after this.
*/
void
- do_step(VectorType & dst,
+ do_step(VectorType &dst,
const VectorType &prev,
const VectorType &src,
const bool backward) const;
const typename PreconditionBlockBase<InverseNumberType>::Inversion
inversion,
const double threshold,
- VectorType * temp_ghost_vector)
+ VectorType *temp_ghost_vector)
: relaxation(relaxation)
, invert_diagonal(invert_diagonal)
, same_diagonal(same_diagonal)
template <typename MatrixType, typename InverseNumberType, typename VectorType>
inline void
RelaxationBlock<MatrixType, InverseNumberType, VectorType>::initialize(
- const MatrixType & M,
+ const MatrixType &M,
const AdditionalData ¶meters)
{
Assert(parameters.invert_diagonal, ExcNotImplemented());
const size_type block_begin,
const size_type block_end)
{
- const MatrixType & M = *(this->A);
+ const MatrixType &M = *(this->A);
FullMatrix<InverseNumberType> M_cell;
for (size_type block = block_begin; block < block_end; ++block)
template <>
inline const TrilinosWrappers::MPI::Vector &
prepare_ghost_vector(const TrilinosWrappers::MPI::Vector &prev,
- TrilinosWrappers::MPI::Vector * other)
+ TrilinosWrappers::MPI::Vector *other)
{
Assert(
other != nullptr,
template <typename MatrixType, typename InverseNumberType, typename VectorType>
inline void
RelaxationBlock<MatrixType, InverseNumberType, VectorType>::do_step(
- VectorType & dst,
+ VectorType &dst,
const VectorType &prev,
const VectorType &src,
const bool backward) const
const VectorType &ghosted_prev =
internal::prepare_ghost_vector(prev, additional_data->temp_ghost_vector);
- const MatrixType & M = *this->A;
+ const MatrixType &M = *this->A;
Vector<typename VectorType::value_type> b_cell, x_cell;
const bool permutation_empty = additional_data->order.empty();
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockJacobi<MatrixType, InverseNumberType, VectorType>::step(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
GrowingVectorMemory<VectorType> mem;
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockJacobi<MatrixType, InverseNumberType, VectorType>::Tstep(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
GrowingVectorMemory<VectorType> mem;
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockJacobi<MatrixType, InverseNumberType, VectorType>::vmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
GrowingVectorMemory<VectorType> mem;
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockJacobi<MatrixType, InverseNumberType, VectorType>::Tvmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
GrowingVectorMemory<VectorType> mem;
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockSOR<MatrixType, InverseNumberType, VectorType>::step(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
this->do_step(dst, dst, src, false);
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockSOR<MatrixType, InverseNumberType, VectorType>::Tstep(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
this->do_step(dst, dst, src, true);
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockSOR<MatrixType, InverseNumberType, VectorType>::vmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
dst = 0;
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockSOR<MatrixType, InverseNumberType, VectorType>::Tvmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
dst = 0;
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockSSOR<MatrixType, InverseNumberType, VectorType>::step(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
this->do_step(dst, dst, src, false);
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockSSOR<MatrixType, InverseNumberType, VectorType>::Tstep(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
this->do_step(dst, dst, src, true);
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockSSOR<MatrixType, InverseNumberType, VectorType>::vmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
dst = 0;
template <typename MatrixType, typename InverseNumberType, typename VectorType>
void
RelaxationBlockSSOR<MatrixType, InverseNumberType, VectorType>::Tvmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
dst = 0;
* In general, it is recommended to use powers of $2$, e.g. $16,32,64, \dots$.
*/
ScaLAPACKMatrix(
- const std::string & filename,
+ const std::string &filename,
const std::shared_ptr<const Utilities::MPI::ProcessGrid> &process_grid,
const size_type row_block_size = 32,
const size_type column_block_size = 32);
* with the same MPI communicator.
*/
void
- copy_to(ScaLAPACKMatrix<NumberType> & B,
+ copy_to(ScaLAPACKMatrix<NumberType> &B,
const std::pair<unsigned int, unsigned int> &offset_A,
const std::pair<unsigned int, unsigned int> &offset_B,
const std::pair<unsigned int, unsigned int> &submatrix_size) const;
mult(const NumberType b,
const ScaLAPACKMatrix<NumberType> &B,
const NumberType c,
- ScaLAPACKMatrix<NumberType> & C,
+ ScaLAPACKMatrix<NumberType> &C,
const bool transpose_A = false,
const bool transpose_B = false) const;
* $NB_A=MB_B$ and $NB_B=NB_C$.
*/
void
- mmult(ScaLAPACKMatrix<NumberType> & C,
+ mmult(ScaLAPACKMatrix<NumberType> &C,
const ScaLAPACKMatrix<NumberType> &B,
const bool adding = false) const;
* $NB_A=MB_C$ and $NB_B=NB_C$.
*/
void
- Tmmult(ScaLAPACKMatrix<NumberType> & C,
+ Tmmult(ScaLAPACKMatrix<NumberType> &C,
const ScaLAPACKMatrix<NumberType> &B,
const bool adding = false) const;
* $NB_A=NB_B$ and $MB_B=NB_C$.
*/
void
- mTmult(ScaLAPACKMatrix<NumberType> & C,
+ mTmult(ScaLAPACKMatrix<NumberType> &C,
const ScaLAPACKMatrix<NumberType> &B,
const bool adding = false) const;
* $NB_A=MB_C$ and $MB_B=NB_C$.
*/
void
- TmTmult(ScaLAPACKMatrix<NumberType> & C,
+ TmTmult(ScaLAPACKMatrix<NumberType> &C,
const ScaLAPACKMatrix<NumberType> &B,
const bool adding = false) const;
* and <tt>chunk_size.second</tt> the number of columns.
*/
void
- save(const std::string & filename,
+ save(const std::string &filename,
const std::pair<unsigned int, unsigned int> &chunk_size =
std::make_pair(numbers::invalid_unsigned_int,
numbers::invalid_unsigned_int)) const;
* using serial routines
*/
void
- save_serial(const std::string & filename,
+ save_serial(const std::string &filename,
const std::pair<unsigned int, unsigned int> &chunk_size) const;
/*
* using parallel routines
*/
void
- save_parallel(const std::string & filename,
+ save_parallel(const std::string &filename,
const std::pair<unsigned int, unsigned int> &chunk_size) const;
/*
* https://www.ibm.com/support/knowledgecenter/en/SSNR5K_4.2.0/com.ibm.cluster.pessl.v4r2.pssl100.doc/am6gr_dbint.htm
*/
void
- Cblacs_gridinit(int * context,
+ Cblacs_gridinit(int *context,
const char *order,
int grid_height,
int grid_width);
*/
void
pdpotrf_(const char *UPLO,
- const int * N,
- double * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO);
+ const int *N,
+ double *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO);
void
pspotrf_(const char *UPLO,
- const int * N,
- float * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO);
+ const int *N,
+ float *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO);
/**
* Computes an LU factorization of a general distributed matrix sub( A )
void
pdgetrf_(const int *m,
const int *n,
- double * A,
+ double *A,
const int *IA,
const int *JA,
const int *DESCA,
- int * ipiv,
- int * INFO);
+ int *ipiv,
+ int *INFO);
void
psgetrf_(const int *m,
const int *n,
- float * A,
+ float *A,
const int *IA,
const int *JA,
const int *DESCA,
- int * ipiv,
- int * INFO);
+ int *ipiv,
+ int *INFO);
/**
* Compute the inverse of a real symmetric positive definite
*/
void
pdpotri_(const char *UPLO,
- const int * N,
- double * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO);
+ const int *N,
+ double *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO);
void
pspotri_(const char *UPLO,
- const int * N,
- float * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO);
+ const int *N,
+ float *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO);
/**
* PDGETRI computes the inverse of a distributed matrix using the LU
*/
void
pdgetri_(const int *N,
- double * A,
+ double *A,
const int *IA,
const int *JA,
const int *DESCA,
const int *ipiv,
- double * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * info);
+ double *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *info);
void
psgetri_(const int *N,
- float * A,
+ float *A,
const int *IA,
const int *JA,
const int *DESCA,
const int *ipiv,
- float * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * info);
+ float *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *info);
/**
void
pdtrtri_(const char *UPLO,
const char *DIAG,
- const int * N,
- double * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO);
+ const int *N,
+ double *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO);
void
pstrtri_(const char *UPLO,
const char *DIAG,
- const int * N,
- float * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO);
+ const int *N,
+ float *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO);
/**
* Estimate the reciprocal of the condition number (in the
* https://software.intel.com/en-us/mkl-developer-reference-fortran-pocon
*/
void
- pdpocon_(const char * uplo,
- const int * N,
+ pdpocon_(const char *uplo,
+ const int *N,
const double *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const double *ANORM,
- double * RCOND,
- double * WORK,
- const int * LWORK,
- int * IWORK,
- const int * LIWORK,
- int * INFO);
+ double *RCOND,
+ double *WORK,
+ const int *LWORK,
+ int *IWORK,
+ const int *LIWORK,
+ int *INFO);
void
- pspocon_(const char * uplo,
- const int * N,
+ pspocon_(const char *uplo,
+ const int *N,
const float *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const float *ANORM,
- float * RCOND,
- float * WORK,
- const int * LWORK,
- int * IWORK,
- const int * LIWORK,
- int * INFO);
+ float *RCOND,
+ float *WORK,
+ const int *LWORK,
+ int *IWORK,
+ const int *LIWORK,
+ int *INFO);
/**
* Norm of a real symmetric matrix
* https://www.ibm.com/support/knowledgecenter/SSNR5K_4.2.0/com.ibm.cluster.pessl.v4r2.pssl100.doc/am6gr_pdlansy.htm#pdlansy
*/
double
- pdlansy_(const char * norm,
- const char * uplo,
- const int * N,
+ pdlansy_(const char *norm,
+ const char *uplo,
+ const int *N,
const double *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- double * work);
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ double *work);
float
- pslansy_(const char * norm,
- const char * uplo,
- const int * N,
+ pslansy_(const char *norm,
+ const char *uplo,
+ const int *N,
const float *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- float * work);
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ float *work);
/**
* Compute the Least Common Multiple (LCM) of two positive integers @p M and @p N.
* Initialize the descriptor vector with the 8 input arguments
*/
void
- descinit_(int * desc,
+ descinit_(int *desc,
const int *m,
const int *n,
const int *mb,
const int *icsrc,
const int *ictxt,
const int *lld,
- int * info);
+ int *info);
/**
* Compute the global index of a distributed matrix entry
void
pdgesv_(const int *n,
const int *nrhs,
- double * A,
+ double *A,
const int *ia,
const int *ja,
const int *desca,
- int * ipiv,
- double * B,
+ int *ipiv,
+ double *B,
const int *ib,
const int *jb,
const int *descb,
- int * info);
+ int *info);
void
psgesv_(const int *n,
const int *nrhs,
- float * A,
+ float *A,
const int *ia,
const int *ja,
const int *desca,
- int * ipiv,
- float * B,
+ int *ipiv,
+ float *B,
const int *ib,
const int *jb,
const int *descb,
- int * info);
+ int *info);
/**
* Perform one of the matrix-matrix operations:
* $op(X) = X$ or $op(X) = X^T$.
*/
void
- pdgemm_(const char * transa,
- const char * transb,
- const int * m,
- const int * n,
- const int * k,
+ pdgemm_(const char *transa,
+ const char *transb,
+ const int *m,
+ const int *n,
+ const int *k,
const double *alpha,
const double *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const double *B,
- const int * IB,
- const int * JB,
- const int * DESCB,
+ const int *IB,
+ const int *JB,
+ const int *DESCB,
const double *beta,
- double * C,
- const int * IC,
- const int * JC,
- const int * DESCC);
+ double *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC);
void
- psgemm_(const char * transa,
- const char * transb,
- const int * m,
- const int * n,
- const int * k,
+ psgemm_(const char *transa,
+ const char *transb,
+ const int *m,
+ const int *n,
+ const int *k,
const float *alpha,
const float *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const float *B,
- const int * IB,
- const int * JB,
- const int * DESCB,
+ const int *IB,
+ const int *JB,
+ const int *DESCB,
const float *beta,
- float * C,
- const int * IC,
- const int * JC,
- const int * DESCC);
+ float *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC);
/**
* Return the value of the one norm, or the Frobenius norm, or the infinity
* norm, or the element of largest absolute value of a distributed matrix
*/
double
- pdlange_(const char * norm,
- const int * m,
- const int * n,
+ pdlange_(const char *norm,
+ const int *m,
+ const int *n,
const double *A,
- const int * ia,
- const int * ja,
- const int * desca,
- double * work);
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ double *work);
float
- pslange_(const char * norm,
- const int * m,
- const int * n,
+ pslange_(const char *norm,
+ const int *m,
+ const int *n,
const float *A,
- const int * ia,
- const int * ja,
- const int * desca,
- float * work);
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ float *work);
/**
* Compute the process coordinate which possesses the entry of a
void
pdsyev_(const char *jobz,
const char *uplo,
- const int * m,
- double * A,
- const int * ia,
- const int * ja,
- int * desca,
- double * w,
- double * z,
- const int * iz,
- const int * jz,
- int * descz,
- double * work,
- const int * lwork,
- int * info);
+ const int *m,
+ double *A,
+ const int *ia,
+ const int *ja,
+ int *desca,
+ double *w,
+ double *z,
+ const int *iz,
+ const int *jz,
+ int *descz,
+ double *work,
+ const int *lwork,
+ int *info);
void
pssyev_(const char *jobz,
const char *uplo,
- const int * m,
- float * A,
- const int * ia,
- const int * ja,
- int * desca,
- float * w,
- float * z,
- const int * iz,
- const int * jz,
- int * descz,
- float * work,
- const int * lwork,
- int * info);
+ const int *m,
+ float *A,
+ const int *ia,
+ const int *ja,
+ int *desca,
+ float *w,
+ float *z,
+ const int *iz,
+ const int *jz,
+ int *descz,
+ float *work,
+ const int *lwork,
+ int *info);
/**
* Copy all or a part of a distributed matrix A to another distributed matrix
* $B(ib:ib+m-1, jb:jb+n-1)$.
*/
void
- pdlacpy_(const char * uplo,
- const int * m,
- const int * n,
+ pdlacpy_(const char *uplo,
+ const int *m,
+ const int *n,
const double *A,
- const int * ia,
- const int * ja,
- const int * desca,
- double * B,
- const int * ib,
- const int * jb,
- const int * descb);
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ double *B,
+ const int *ib,
+ const int *jb,
+ const int *descb);
void
- pslacpy_(const char * uplo,
- const int * m,
- const int * n,
+ pslacpy_(const char *uplo,
+ const int *m,
+ const int *n,
const float *A,
- const int * ia,
- const int * ja,
- const int * desca,
- float * B,
- const int * ib,
- const int * jb,
- const int * descb);
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ float *B,
+ const int *ib,
+ const int *jb,
+ const int *descb);
/**
* Copies the content of a general rectangular distributed matrix @p A to another distributed matrix @p B
* A and B
*/
void
- pdgemr2d_(const int * m,
- const int * n,
+ pdgemr2d_(const int *m,
+ const int *n,
const double *A,
- const int * ia,
- const int * ja,
- const int * desca,
- double * B,
- const int * ib,
- const int * jb,
- const int * descb,
- const int * ictxt);
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ double *B,
+ const int *ib,
+ const int *jb,
+ const int *descb,
+ const int *ictxt);
void
- psgemr2d_(const int * m,
- const int * n,
+ psgemr2d_(const int *m,
+ const int *n,
const float *A,
- const int * ia,
- const int * ja,
- const int * desca,
- float * B,
- const int * ib,
- const int * jb,
- const int * descb,
- const int * ictxt);
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ float *B,
+ const int *ib,
+ const int *jb,
+ const int *descb,
+ const int *ictxt);
/**
* helper routines determining machine precision
* eigenvalues.
*/
void
- pdsyevx_(const char * jobz,
- const char * range,
- const char * uplo,
- const int * n,
- double * A,
- const int * ia,
- const int * ja,
- const int * desca,
+ pdsyevx_(const char *jobz,
+ const char *range,
+ const char *uplo,
+ const int *n,
+ double *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
const double *VL,
const double *VU,
- const int * il,
- const int * iu,
+ const int *il,
+ const int *iu,
const double *abstol,
- const int * m,
- const int * nz,
- double * w,
- double * orfac,
- double * Z,
- const int * iz,
- const int * jz,
- const int * descz,
- double * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * ifail,
- int * iclustr,
- double * gap,
- int * info);
+ const int *m,
+ const int *nz,
+ double *w,
+ double *orfac,
+ double *Z,
+ const int *iz,
+ const int *jz,
+ const int *descz,
+ double *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *ifail,
+ int *iclustr,
+ double *gap,
+ int *info);
void
- pssyevx_(const char * jobz,
- const char * range,
- const char * uplo,
- const int * n,
- float * A,
- const int * ia,
- const int * ja,
- const int * desca,
+ pssyevx_(const char *jobz,
+ const char *range,
+ const char *uplo,
+ const int *n,
+ float *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
const float *VL,
const float *VU,
- const int * il,
- const int * iu,
+ const int *il,
+ const int *iu,
const float *abstol,
- const int * m,
- const int * nz,
- float * w,
- float * orfac,
- float * Z,
- const int * iz,
- const int * jz,
- const int * descz,
- float * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * ifail,
- int * iclustr,
- float * gap,
- int * info);
+ const int *m,
+ const int *nz,
+ float *w,
+ float *orfac,
+ float *Z,
+ const int *iz,
+ const int *jz,
+ const int *descz,
+ float *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *ifail,
+ int *iclustr,
+ float *gap,
+ int *info);
/*
* PDGESVD computes the singular value decomposition (SVD) of an
void
pdgesvd_(const char *jobu,
const char *jobvt,
- const int * m,
- const int * n,
- double * A,
- const int * ia,
- const int * ja,
- const int * desca,
- double * S,
- double * U,
- const int * iu,
- const int * ju,
- const int * descu,
- double * VT,
- const int * ivt,
- const int * jvt,
- const int * descvt,
- double * work,
- int * lwork,
- int * info);
+ const int *m,
+ const int *n,
+ double *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ double *S,
+ double *U,
+ const int *iu,
+ const int *ju,
+ const int *descu,
+ double *VT,
+ const int *ivt,
+ const int *jvt,
+ const int *descvt,
+ double *work,
+ int *lwork,
+ int *info);
void
psgesvd_(const char *jobu,
const char *jobvt,
- const int * m,
- const int * n,
- float * A,
- const int * ia,
- const int * ja,
- const int * desca,
- float * S,
- float * U,
- const int * iu,
- const int * ju,
- const int * descu,
- float * VT,
- const int * ivt,
- const int * jvt,
- const int * descvt,
- float * work,
- int * lwork,
- int * info);
+ const int *m,
+ const int *n,
+ float *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ float *S,
+ float *U,
+ const int *iu,
+ const int *ju,
+ const int *descu,
+ float *VT,
+ const int *ivt,
+ const int *jvt,
+ const int *descvt,
+ float *work,
+ int *lwork,
+ int *info);
/*
* P_GELS solves overdetermined or underdetermined real linear
*/
void
pdgels_(const char *trans,
- const int * m,
- const int * n,
- const int * nrhs,
- double * A,
- const int * ia,
- const int * ja,
- const int * desca,
- double * B,
- const int * ib,
- const int * jb,
- const int * descb,
- double * work,
- int * lwork,
- int * info);
+ const int *m,
+ const int *n,
+ const int *nrhs,
+ double *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ double *B,
+ const int *ib,
+ const int *jb,
+ const int *descb,
+ double *work,
+ int *lwork,
+ int *info);
void
psgels_(const char *trans,
- const int * m,
- const int * n,
- const int * nrhs,
- float * A,
- const int * ia,
- const int * ja,
- const int * desca,
- float * B,
- const int * ib,
- const int * jb,
- const int * descb,
- float * work,
- int * lwork,
- int * info);
+ const int *m,
+ const int *n,
+ const int *nrhs,
+ float *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ float *B,
+ const int *ib,
+ const int *jb,
+ const int *descb,
+ float *work,
+ int *lwork,
+ int *info);
/*
* Perform matrix sum:
* where $op(A)$ denotes either $op(A) = A$ or $op(A)=A^T$.
*/
void
- pdgeadd_(const char * transa,
- const int * m,
- const int * n,
+ pdgeadd_(const char *transa,
+ const int *m,
+ const int *n,
const double *alpha,
const double *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const double *beta,
- double * C,
- const int * IC,
- const int * JC,
- const int * DESCC);
+ double *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC);
void
- psgeadd_(const char * transa,
- const int * m,
- const int * n,
+ psgeadd_(const char *transa,
+ const int *m,
+ const int *n,
const float *alpha,
const float *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const float *beta,
- float * C,
- const int * IC,
- const int * JC,
- const int * DESCC);
+ float *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC);
/**
* Routine to transpose a matrix:
* C = beta C + alpha A^T
*/
void
- pdtran_(const int * m,
- const int * n,
+ pdtran_(const int *m,
+ const int *n,
const double *alpha,
const double *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const double *beta,
- double * C,
- const int * IC,
- const int * JC,
- const int * DESCC);
+ double *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC);
void
- pstran_(const int * m,
- const int * n,
+ pstran_(const int *m,
+ const int *n,
const float *alpha,
const float *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const float *beta,
- float * C,
- const int * IC,
- const int * JC,
- const int * DESCC);
+ float *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC);
/**
* psyevr computes selected eigenvalues and, optionally, eigenvectors
* values or a range of indices for the desired eigenvalues.
*/
void
- pdsyevr_(const char * jobz,
- const char * range,
- const char * uplo,
- const int * n,
- double * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ pdsyevr_(const char *jobz,
+ const char *range,
+ const char *uplo,
+ const int *n,
+ double *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const double *VL,
const double *VU,
- const int * IL,
- const int * IU,
- int * m,
- int * nz,
- double * w,
- double * Z,
- const int * IZ,
- const int * JZ,
- const int * DESCZ,
- double * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * info);
+ const int *IL,
+ const int *IU,
+ int *m,
+ int *nz,
+ double *w,
+ double *Z,
+ const int *IZ,
+ const int *JZ,
+ const int *DESCZ,
+ double *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *info);
void
- pssyevr_(const char * jobz,
- const char * range,
- const char * uplo,
- const int * n,
- float * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ pssyevr_(const char *jobz,
+ const char *range,
+ const char *uplo,
+ const int *n,
+ float *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const float *VL,
const float *VU,
- const int * IL,
- const int * IU,
- int * m,
- int * nz,
- float * w,
- float * Z,
- const int * IZ,
- const int * JZ,
- const int * DESCZ,
- float * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * info);
+ const int *IL,
+ const int *IU,
+ int *m,
+ int *nz,
+ float *w,
+ float *Z,
+ const int *IZ,
+ const int *JZ,
+ const int *DESCZ,
+ float *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *info);
}
inline void
ppotrf(const char *UPLO,
- const int * N,
- double * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO)
+ const int *N,
+ double *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO)
{
pdpotrf_(UPLO, N, A, IA, JA, DESCA, INFO);
}
inline void
ppotrf(const char *UPLO,
- const int * N,
- float * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO)
+ const int *N,
+ float *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO)
{
pspotrf_(UPLO, N, A, IA, JA, DESCA, INFO);
}
inline void
pgetrf(const int *m,
const int *n,
- double * A,
+ double *A,
const int *IA,
const int *JA,
const int *DESCA,
- int * ipiv,
- int * INFO)
+ int *ipiv,
+ int *INFO)
{
pdgetrf_(m, n, A, IA, JA, DESCA, ipiv, INFO);
}
inline void
pgetrf(const int *m,
const int *n,
- float * A,
+ float *A,
const int *IA,
const int *JA,
const int *DESCA,
- int * ipiv,
- int * INFO)
+ int *ipiv,
+ int *INFO)
{
psgetrf_(m, n, A, IA, JA, DESCA, ipiv, INFO);
}
inline void
ppotri(const char *UPLO,
- const int * N,
- double * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO)
+ const int *N,
+ double *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO)
{
pdpotri_(UPLO, N, A, IA, JA, DESCA, INFO);
}
inline void
ppotri(const char *UPLO,
- const int * N,
- float * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO)
+ const int *N,
+ float *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO)
{
pspotri_(UPLO, N, A, IA, JA, DESCA, INFO);
}
inline void
pgetri(const int *N,
- double * A,
+ double *A,
const int *IA,
const int *JA,
const int *DESCA,
const int *ipiv,
- double * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * info)
+ double *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *info)
{
pdgetri_(N, A, IA, JA, DESCA, ipiv, work, lwork, iwork, liwork, info);
}
inline void
pgetri(const int *N,
- float * A,
+ float *A,
const int *IA,
const int *JA,
const int *DESCA,
const int *ipiv,
- float * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * info)
+ float *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *info)
{
psgetri_(N, A, IA, JA, DESCA, ipiv, work, lwork, iwork, liwork, info);
}
inline void
ptrtri(const char *UPLO,
const char *DIAG,
- const int * N,
- double * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO)
+ const int *N,
+ double *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO)
{
pdtrtri_(UPLO, DIAG, N, A, IA, JA, DESCA, INFO);
}
inline void
ptrtri(const char *UPLO,
const char *DIAG,
- const int * N,
- float * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- int * INFO)
+ const int *N,
+ float *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ int *INFO)
{
pstrtri_(UPLO, DIAG, N, A, IA, JA, DESCA, INFO);
}
}
inline void
-ppocon(const char * uplo,
- const int * N,
+ppocon(const char *uplo,
+ const int *N,
const double *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const double *ANORM,
- double * RCOND,
- double * WORK,
- const int * LWORK,
- int * IWORK,
- const int * LIWORK,
- int * INFO)
+ double *RCOND,
+ double *WORK,
+ const int *LWORK,
+ int *IWORK,
+ const int *LIWORK,
+ int *INFO)
{
pdpocon_(
uplo, N, A, IA, JA, DESCA, ANORM, RCOND, WORK, LWORK, IWORK, LIWORK, INFO);
}
inline void
-ppocon(const char * uplo,
- const int * N,
+ppocon(const char *uplo,
+ const int *N,
const float *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const float *ANORM,
- float * RCOND,
- float * WORK,
- const int * LWORK,
- int * IWORK,
- const int * LIWORK,
- int * INFO)
+ float *RCOND,
+ float *WORK,
+ const int *LWORK,
+ int *IWORK,
+ const int *LIWORK,
+ int *INFO)
{
pspocon_(
uplo, N, A, IA, JA, DESCA, ANORM, RCOND, WORK, LWORK, IWORK, LIWORK, INFO);
}
inline double
-plansy(const char * norm,
- const char * uplo,
- const int * N,
+plansy(const char *norm,
+ const char *uplo,
+ const int *N,
const double *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- double * work)
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ double *work)
{
return pdlansy_(norm, uplo, N, A, IA, JA, DESCA, work);
}
inline float
-plansy(const char * norm,
- const char * uplo,
- const int * N,
+plansy(const char *norm,
+ const char *uplo,
+ const int *N,
const float *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
- float * work)
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
+ float *work)
{
return pslansy_(norm, uplo, N, A, IA, JA, DESCA, work);
}
inline void
pgesv(const int *n,
const int *nrhs,
- double * A,
+ double *A,
const int *ia,
const int *ja,
const int *desca,
- int * ipiv,
- double * B,
+ int *ipiv,
+ double *B,
const int *ib,
const int *jb,
const int *descb,
- int * info)
+ int *info)
{
pdgesv_(n, nrhs, A, ia, ja, desca, ipiv, B, ib, jb, descb, info);
}
inline void
pgesv(const int *n,
const int *nrhs,
- float * A,
+ float *A,
const int *ia,
const int *ja,
const int *desca,
- int * ipiv,
- float * B,
+ int *ipiv,
+ float *B,
const int *ib,
const int *jb,
const int *descb,
- int * info)
+ int *info)
{
psgesv_(n, nrhs, A, ia, ja, desca, ipiv, B, ib, jb, descb, info);
}
}
inline void
-pgemm(const char * transa,
- const char * transb,
- const int * m,
- const int * n,
- const int * k,
+pgemm(const char *transa,
+ const char *transb,
+ const int *m,
+ const int *n,
+ const int *k,
const double *alpha,
const double *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const double *B,
- const int * IB,
- const int * JB,
- const int * DESCB,
+ const int *IB,
+ const int *JB,
+ const int *DESCB,
const double *beta,
- double * C,
- const int * IC,
- const int * JC,
- const int * DESCC)
+ double *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC)
{
pdgemm_(transa,
transb,
}
inline void
-pgemm(const char * transa,
- const char * transb,
- const int * m,
- const int * n,
- const int * k,
+pgemm(const char *transa,
+ const char *transb,
+ const int *m,
+ const int *n,
+ const int *k,
const float *alpha,
const float *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const float *B,
- const int * IB,
- const int * JB,
- const int * DESCB,
+ const int *IB,
+ const int *JB,
+ const int *DESCB,
const float *beta,
- float * C,
- const int * IC,
- const int * JC,
- const int * DESCC)
+ float *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC)
{
psgemm_(transa,
transb,
}
inline double
-plange(const char * norm,
- const int * m,
- const int * n,
+plange(const char *norm,
+ const int *m,
+ const int *n,
const double *A,
- const int * ia,
- const int * ja,
- const int * desca,
- double * work)
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ double *work)
{
return pdlange_(norm, m, n, A, ia, ja, desca, work);
}
inline float
-plange(const char * norm,
- const int * m,
- const int * n,
+plange(const char *norm,
+ const int *m,
+ const int *n,
const float *A,
- const int * ia,
- const int * ja,
- const int * desca,
- float * work)
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ float *work)
{
return pslange_(norm, m, n, A, ia, ja, desca, work);
}
inline void
psyev(const char *jobz,
const char *uplo,
- const int * m,
- double * A,
- const int * ia,
- const int * ja,
- int * desca,
- double * w,
- double * z,
- const int * iz,
- const int * jz,
- int * descz,
- double * work,
- const int * lwork,
- int * info)
+ const int *m,
+ double *A,
+ const int *ia,
+ const int *ja,
+ int *desca,
+ double *w,
+ double *z,
+ const int *iz,
+ const int *jz,
+ int *descz,
+ double *work,
+ const int *lwork,
+ int *info)
{
pdsyev_(
jobz, uplo, m, A, ia, ja, desca, w, z, iz, jz, descz, work, lwork, info);
inline void
psyev(const char *jobz,
const char *uplo,
- const int * m,
- float * A,
- const int * ia,
- const int * ja,
- int * desca,
- float * w,
- float * z,
- const int * iz,
- const int * jz,
- int * descz,
- float * work,
- const int * lwork,
- int * info)
+ const int *m,
+ float *A,
+ const int *ia,
+ const int *ja,
+ int *desca,
+ float *w,
+ float *z,
+ const int *iz,
+ const int *jz,
+ int *descz,
+ float *work,
+ const int *lwork,
+ int *info)
{
pssyev_(
jobz, uplo, m, A, ia, ja, desca, w, z, iz, jz, descz, work, lwork, info);
}
inline void
-placpy(const char * uplo,
- const int * m,
- const int * n,
+placpy(const char *uplo,
+ const int *m,
+ const int *n,
const double *A,
- const int * ia,
- const int * ja,
- const int * desca,
- double * B,
- const int * ib,
- const int * jb,
- const int * descb)
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ double *B,
+ const int *ib,
+ const int *jb,
+ const int *descb)
{
pdlacpy_(uplo, m, n, A, ia, ja, desca, B, ib, jb, descb);
}
inline void
-placpy(const char * uplo,
- const int * m,
- const int * n,
+placpy(const char *uplo,
+ const int *m,
+ const int *n,
const float *A,
- const int * ia,
- const int * ja,
- const int * desca,
- float * B,
- const int * ib,
- const int * jb,
- const int * descb)
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ float *B,
+ const int *ib,
+ const int *jb,
+ const int *descb)
{
pslacpy_(uplo, m, n, A, ia, ja, desca, B, ib, jb, descb);
}
}
inline void
-pgemr2d(const int * m,
- const int * n,
+pgemr2d(const int *m,
+ const int *n,
const double *A,
- const int * ia,
- const int * ja,
- const int * desca,
- double * B,
- const int * ib,
- const int * jb,
- const int * descb,
- const int * ictxt)
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ double *B,
+ const int *ib,
+ const int *jb,
+ const int *descb,
+ const int *ictxt)
{
pdgemr2d_(m, n, A, ia, ja, desca, B, ib, jb, descb, ictxt);
}
inline void
-pgemr2d(const int * m,
- const int * n,
+pgemr2d(const int *m,
+ const int *n,
const float *A,
- const int * ia,
- const int * ja,
- const int * desca,
- float * B,
- const int * ib,
- const int * jb,
- const int * descb,
- const int * ictxt)
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ float *B,
+ const int *ib,
+ const int *jb,
+ const int *descb,
+ const int *ictxt)
{
psgemr2d_(m, n, A, ia, ja, desca, B, ib, jb, descb, ictxt);
}
psyevx(const char *jobz,
const char *range,
const char *uplo,
- const int * n,
- double * A,
- const int * ia,
- const int * ja,
- const int * desca,
- double * VL,
- double * VU,
- const int * il,
- const int * iu,
- double * abstol,
- const int * m,
- const int * nz,
- double * w,
- double * orfac,
- double * Z,
- const int * iz,
- const int * jz,
- const int * descz,
- double * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * ifail,
- int * iclustr,
- double * gap,
- int * info)
+ const int *n,
+ double *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ double *VL,
+ double *VU,
+ const int *il,
+ const int *iu,
+ double *abstol,
+ const int *m,
+ const int *nz,
+ double *w,
+ double *orfac,
+ double *Z,
+ const int *iz,
+ const int *jz,
+ const int *descz,
+ double *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *ifail,
+ int *iclustr,
+ double *gap,
+ int *info)
{
pdsyevx_(jobz,
range,
psyevx(const char *jobz,
const char *range,
const char *uplo,
- const int * n,
- float * A,
- const int * ia,
- const int * ja,
- const int * desca,
- float * VL,
- float * VU,
- const int * il,
- const int * iu,
- float * abstol,
- const int * m,
- const int * nz,
- float * w,
- float * orfac,
- float * Z,
- const int * iz,
- const int * jz,
- const int * descz,
- float * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * ifail,
- int * iclustr,
- float * gap,
- int * info)
+ const int *n,
+ float *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ float *VL,
+ float *VU,
+ const int *il,
+ const int *iu,
+ float *abstol,
+ const int *m,
+ const int *nz,
+ float *w,
+ float *orfac,
+ float *Z,
+ const int *iz,
+ const int *jz,
+ const int *descz,
+ float *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *ifail,
+ int *iclustr,
+ float *gap,
+ int *info)
{
pssyevx_(jobz,
range,
inline void
pgesvd(const char *jobu,
const char *jobvt,
- const int * m,
- const int * n,
- double * A,
- const int * ia,
- const int * ja,
- const int * desca,
- double * S,
- double * U,
- const int * iu,
- const int * ju,
- const int * descu,
- double * VT,
- const int * ivt,
- const int * jvt,
- const int * descvt,
- double * work,
- int * lwork,
- int * info)
+ const int *m,
+ const int *n,
+ double *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ double *S,
+ double *U,
+ const int *iu,
+ const int *ju,
+ const int *descu,
+ double *VT,
+ const int *ivt,
+ const int *jvt,
+ const int *descvt,
+ double *work,
+ int *lwork,
+ int *info)
{
pdgesvd_(jobu,
jobvt,
inline void
pgesvd(const char *jobu,
const char *jobvt,
- const int * m,
- const int * n,
- float * A,
- const int * ia,
- const int * ja,
- const int * desca,
- float * S,
- float * U,
- const int * iu,
- const int * ju,
- const int * descu,
- float * VT,
- const int * ivt,
- const int * jvt,
- const int * descvt,
- float * work,
- int * lwork,
- int * info)
+ const int *m,
+ const int *n,
+ float *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ float *S,
+ float *U,
+ const int *iu,
+ const int *ju,
+ const int *descu,
+ float *VT,
+ const int *ivt,
+ const int *jvt,
+ const int *descvt,
+ float *work,
+ int *lwork,
+ int *info)
{
psgesvd_(jobu,
jobvt,
inline void
pgels(const char *trans,
- const int * m,
- const int * n,
- const int * nrhs,
- double * A,
- const int * ia,
- const int * ja,
- const int * desca,
- double * B,
- const int * ib,
- const int * jb,
- const int * descb,
- double * work,
- int * lwork,
- int * info)
+ const int *m,
+ const int *n,
+ const int *nrhs,
+ double *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ double *B,
+ const int *ib,
+ const int *jb,
+ const int *descb,
+ double *work,
+ int *lwork,
+ int *info)
{
pdgels_(
trans, m, n, nrhs, A, ia, ja, desca, B, ib, jb, descb, work, lwork, info);
inline void
pgels(const char *trans,
- const int * m,
- const int * n,
- const int * nrhs,
- float * A,
- const int * ia,
- const int * ja,
- const int * desca,
- float * B,
- const int * ib,
- const int * jb,
- const int * descb,
- float * work,
- int * lwork,
- int * info)
+ const int *m,
+ const int *n,
+ const int *nrhs,
+ float *A,
+ const int *ia,
+ const int *ja,
+ const int *desca,
+ float *B,
+ const int *ib,
+ const int *jb,
+ const int *descb,
+ float *work,
+ int *lwork,
+ int *info)
{
psgels_(
trans, m, n, nrhs, A, ia, ja, desca, B, ib, jb, descb, work, lwork, info);
}
inline void
-pgeadd(const char * transa,
- const int * m,
- const int * n,
+pgeadd(const char *transa,
+ const int *m,
+ const int *n,
const double *alpha,
const double *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const double *beta,
- double * C,
- const int * IC,
- const int * JC,
- const int * DESCC)
+ double *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC)
{
pdgeadd_(transa, m, n, alpha, A, IA, JA, DESCA, beta, C, IC, JC, DESCC);
}
inline void
-pgeadd(const char * transa,
- const int * m,
- const int * n,
+pgeadd(const char *transa,
+ const int *m,
+ const int *n,
const float *alpha,
const float *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const float *beta,
- float * C,
- const int * IC,
- const int * JC,
- const int * DESCC)
+ float *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC)
{
psgeadd_(transa, m, n, alpha, A, IA, JA, DESCA, beta, C, IC, JC, DESCC);
}
}
inline void
-ptran(const int * m,
- const int * n,
+ptran(const int *m,
+ const int *n,
const double *alpha,
const double *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const double *beta,
- double * C,
- const int * IC,
- const int * JC,
- const int * DESCC)
+ double *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC)
{
pdtran_(m, n, alpha, A, IA, JA, DESCA, beta, C, IC, JC, DESCC);
}
inline void
-ptran(const int * m,
- const int * n,
+ptran(const int *m,
+ const int *n,
const float *alpha,
const float *A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const float *beta,
- float * C,
- const int * IC,
- const int * JC,
- const int * DESCC)
+ float *C,
+ const int *IC,
+ const int *JC,
+ const int *DESCC)
{
pstran_(m, n, alpha, A, IA, JA, DESCA, beta, C, IC, JC, DESCC);
}
}
inline void
-psyevr(const char * jobz,
- const char * range,
- const char * uplo,
- const int * n,
- double * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+psyevr(const char *jobz,
+ const char *range,
+ const char *uplo,
+ const int *n,
+ double *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const double *VL,
const double *VU,
- const int * IL,
- const int * IU,
- int * m,
- int * nz,
- double * w,
- double * Z,
- const int * IZ,
- const int * JZ,
- const int * DESCZ,
- double * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * info)
+ const int *IL,
+ const int *IU,
+ int *m,
+ int *nz,
+ double *w,
+ double *Z,
+ const int *IZ,
+ const int *JZ,
+ const int *DESCZ,
+ double *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *info)
{
/*
* Netlib ScaLAPACK performs floating point tests (e.g. divide-by-zero) within
}
inline void
-psyevr(const char * jobz,
- const char * range,
- const char * uplo,
- const int * n,
- float * A,
- const int * IA,
- const int * JA,
- const int * DESCA,
+psyevr(const char *jobz,
+ const char *range,
+ const char *uplo,
+ const int *n,
+ float *A,
+ const int *IA,
+ const int *JA,
+ const int *DESCA,
const float *VL,
const float *VU,
- const int * IL,
- const int * IU,
- int * m,
- int * nz,
- float * w,
- float * Z,
- const int * IZ,
- const int * JZ,
- const int * DESCZ,
- float * work,
- int * lwork,
- int * iwork,
- int * liwork,
- int * info)
+ const int *IL,
+ const int *IU,
+ int *m,
+ int *nz,
+ float *w,
+ float *Z,
+ const int *IZ,
+ const int *JZ,
+ const int *DESCZ,
+ float *work,
+ int *lwork,
+ int *iwork,
+ int *liwork,
+ int *info)
{
/*
* Netlib ScaLAPACK performs floating point tests (e.g. divide-by-zero) within
PackagedOperation<Range_2>
condense_schur_rhs(const LinearOperator<Range_1, Domain_1, Payload> &A_inv,
const LinearOperator<Range_2, Domain_1, Payload> &C,
- const Range_1 & f,
- const Range_2 & g)
+ const Range_1 &f,
+ const Range_2 &g)
{
// We return the result of the compound PackagedOperation
// directly, so as to ensure that the underlying Payload
postprocess_schur_solution(
const LinearOperator<Range_1, Domain_1, Payload> &A_inv,
const LinearOperator<Range_1, Domain_2, Payload> &B,
- const Domain_2 & y,
- const Range_1 & f)
+ const Domain_2 &y,
+ const Range_1 &f)
{
// We return the result of the compound PackagedOperation
// directly, so as to ensure that the underlying Payload
template <typename OutputVector>
void
solve(const PETScWrappers::MatrixBase &A,
- std::vector<PetscScalar> & eigenvalues,
- std::vector<OutputVector> & eigenvectors,
+ std::vector<PetscScalar> &eigenvalues,
+ std::vector<OutputVector> &eigenvectors,
const unsigned int n_eigenpairs = 1);
/**
void
solve(const PETScWrappers::MatrixBase &A,
const PETScWrappers::MatrixBase &B,
- std::vector<PetscScalar> & eigenvalues,
- std::vector<OutputVector> & eigenvectors,
+ std::vector<PetscScalar> &eigenvalues,
+ std::vector<OutputVector> &eigenvectors,
const unsigned int n_eigenpairs = 1);
/**
void
solve(const PETScWrappers::MatrixBase &A,
const PETScWrappers::MatrixBase &B,
- std::vector<double> & real_eigenvalues,
- std::vector<double> & imag_eigenvalues,
- std::vector<OutputVector> & real_eigenvectors,
- std::vector<OutputVector> & imag_eigenvectors,
+ std::vector<double> &real_eigenvalues,
+ std::vector<double> &imag_eigenvalues,
+ std::vector<OutputVector> &real_eigenvectors,
+ std::vector<OutputVector> &imag_eigenvectors,
const unsigned int n_eigenpairs = 1);
/**
*/
void
get_eigenpair(const unsigned int index,
- PetscScalar & eigenvalues,
+ PetscScalar &eigenvalues,
PETScWrappers::VectorBase &eigenvectors);
/**
*/
void
get_eigenpair(const unsigned int index,
- double & real_eigenvalues,
- double & imag_eigenvalues,
+ double &real_eigenvalues,
+ double &imag_eigenvalues,
PETScWrappers::VectorBase &real_eigenvectors,
PETScWrappers::VectorBase &imag_eigenvectors);
PetscScalar real_eigenvalue,
PetscScalar imag_eigenvalue,
PetscReal residual_norm,
- PetscReal * estimated_error,
- void * solver_control);
+ PetscReal *estimated_error,
+ void *solver_control);
};
* behavior as the PETScWrappers, but you can change that.
*/
explicit SolverKrylovSchur(
- SolverControl & cn,
+ SolverControl &cn,
const MPI_Comm mpi_communicator = PETSC_COMM_SELF,
const AdditionalData &data = AdditionalData());
* behavior as the PETScWrappers, but you can change that.
*/
explicit SolverGeneralizedDavidson(
- SolverControl & cn,
+ SolverControl &cn,
const MPI_Comm mpi_communicator = PETSC_COMM_SELF,
const AdditionalData &data = AdditionalData());
* behavior as the PETScWrappers, but you can change that.
*/
explicit SolverJacobiDavidson(
- SolverControl & cn,
+ SolverControl &cn,
const MPI_Comm mpi_communicator = PETSC_COMM_SELF,
const AdditionalData &data = AdditionalData());
template <typename OutputVector>
void
SolverBase::solve(const PETScWrappers::MatrixBase &A,
- std::vector<PetscScalar> & eigenvalues,
- std::vector<OutputVector> & eigenvectors,
+ std::vector<PetscScalar> &eigenvalues,
+ std::vector<OutputVector> &eigenvectors,
const unsigned int n_eigenpairs)
{
// Panic if the number of eigenpairs wanted is out of bounds.
void
SolverBase::solve(const PETScWrappers::MatrixBase &A,
const PETScWrappers::MatrixBase &B,
- std::vector<PetscScalar> & eigenvalues,
- std::vector<OutputVector> & eigenvectors,
+ std::vector<PetscScalar> &eigenvalues,
+ std::vector<OutputVector> &eigenvectors,
const unsigned int n_eigenpairs)
{
// Guard against incompatible matrix sizes:
void
SolverBase::solve(const PETScWrappers::MatrixBase &A,
const PETScWrappers::MatrixBase &B,
- std::vector<double> & real_eigenvalues,
- std::vector<double> & imag_eigenvalues,
- std::vector<OutputVector> & real_eigenvectors,
- std::vector<OutputVector> & imag_eigenvectors,
+ std::vector<double> &real_eigenvalues,
+ std::vector<double> &imag_eigenvalues,
+ std::vector<OutputVector> &real_eigenvectors,
+ std::vector<OutputVector> &imag_eigenvectors,
const unsigned int n_eigenpairs)
{
// Guard against incompatible matrix sizes:
* responsibility to guarantee that the lifetime of the two arguments is at
* least as long as that of the solver object.
*/
- SolverBase(SolverControl & solver_control,
+ SolverBase(SolverControl &solver_control,
VectorMemory<VectorType> &vector_memory);
/**
boost::signals2::signal<
SolverControl::State(const unsigned int iteration,
const double check_value,
- const VectorType & current_iterate),
+ const VectorType ¤t_iterate),
StateCombiner>
iteration_status;
};
template <typename VectorType>
inline SolverBase<VectorType>::SolverBase(
- SolverControl & solver_control,
+ SolverControl &solver_control,
VectorMemory<VectorType> &vector_memory)
: memory(vector_memory)
{
SolverBase<VectorType>::connect(
const std::function<SolverControl::State(const unsigned int iteration,
const double check_value,
- const VectorType & current_iterate)>
+ const VectorType ¤t_iterate)>
&slot)
{
return iteration_status.connect(slot);
/**
* Constructor.
*/
- SolverBicgstab(SolverControl & cn,
+ SolverBicgstab(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
* Constructor. Use an object of type GrowingVectorMemory as a default to
* allocate memory.
*/
- SolverBicgstab(SolverControl & cn,
+ SolverBicgstab(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
*/
template <typename MatrixType, typename PreconditionerType>
void
- solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner);
protected:
criterion(const MatrixType &A,
const VectorType &x,
const VectorType &b,
- VectorType & t);
+ VectorType &t);
/**
* Interface for derived class. This function gets the current iteration
*/
virtual void
print_vectors(const unsigned int step,
- const VectorType & x,
- const VectorType & r,
- const VectorType & d) const;
+ const VectorType &x,
+ const VectorType &r,
+ const VectorType &d) const;
/**
* Additional parameters.
*/
template <typename MatrixType, typename PreconditionerType>
IterationResult
- iterate(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ iterate(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner,
const unsigned int step);
};
template <typename VectorType>
-SolverBicgstab<VectorType>::SolverBicgstab(SolverControl & cn,
+SolverBicgstab<VectorType>::SolverBicgstab(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<VectorType>(cn, mem)
, additional_data(data)
{}
template <typename VectorType>
-SolverBicgstab<VectorType>::SolverBicgstab(SolverControl & cn,
+SolverBicgstab<VectorType>::SolverBicgstab(SolverControl &cn,
const AdditionalData &data)
: SolverBase<VectorType>(cn)
, additional_data(data)
SolverBicgstab<VectorType>::criterion(const MatrixType &A,
const VectorType &x,
const VectorType &b,
- VectorType & t)
+ VectorType &t)
{
A.vmult(t, x);
return std::sqrt(t.add_and_dot(-1.0, b, t));
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
typename SolverBicgstab<VectorType>::IterationResult
-SolverBicgstab<VectorType>::iterate(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverBicgstab<VectorType>::iterate(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner,
const unsigned int last_step)
{
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
-SolverBicgstab<VectorType>::solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverBicgstab<VectorType>::solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner)
{
LogStream::Prefix prefix("Bicgstab");
/**
* Constructor.
*/
- SolverCG(SolverControl & cn,
+ SolverCG(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
* Constructor. Use an object of type GrowingVectorMemory as a default to
*/
template <typename MatrixType, typename PreconditionerType>
void
- solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner);
/**
*/
virtual void
print_vectors(const unsigned int step,
- const VectorType & x,
- const VectorType & r,
- const VectorType & d) const;
+ const VectorType &x,
+ const VectorType &r,
+ const VectorType &d) const;
/**
* Estimates the eigenvalues from diagonal and offdiagonal. Uses these
const std::vector<typename VectorType::value_type> &diagonal,
const std::vector<typename VectorType::value_type> &offdiagonal,
const boost::signals2::signal<void(const std::vector<double> &)>
- & eigenvalues_signal,
+ &eigenvalues_signal,
const boost::signals2::signal<void(double)> &cond_signal);
/**
/**
* Constructor.
*/
- SolverFlexibleCG(SolverControl & cn,
+ SolverFlexibleCG(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
* Constructor. Use an object of type GrowingVectorMemory as a default to
* allocate memory.
*/
- SolverFlexibleCG(SolverControl & cn,
+ SolverFlexibleCG(SolverControl &cn,
const AdditionalData &data = AdditionalData());
};
template <typename VectorType>
-SolverCG<VectorType>::SolverCG(SolverControl & cn,
+SolverCG<VectorType>::SolverCG(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<VectorType>(cn, mem)
, additional_data(data)
, determine_beta_by_flexible_formula(false)
const std::vector<typename VectorType::value_type> &diagonal,
const std::vector<typename VectorType::value_type> &offdiagonal,
const boost::signals2::signal<void(const std::vector<double> &)>
- & eigenvalues_signal,
+ &eigenvalues_signal,
const boost::signals2::signal<void(double)> &cond_signal)
{
// Avoid computing eigenvalues unless they are needed.
{
using Number = typename VectorType::value_type;
- const MatrixType & A;
+ const MatrixType &A;
const PreconditionerType &preconditioner;
const bool flexible;
- VectorType & x;
+ VectorType &x;
typename VectorMemory<VectorType>::Pointer r_pointer;
typename VectorMemory<VectorType>::Pointer p_pointer;
double residual_norm;
Number previous_alpha;
- IterationWorkerBase(const MatrixType & A,
+ IterationWorkerBase(const MatrixType &A,
const PreconditionerType &preconditioner,
const bool flexible,
VectorMemory<VectorType> &memory,
- VectorType & x)
+ VectorType &x)
: A(A)
, preconditioner(preconditioner)
, flexible(flexible)
using BaseClass =
IterationWorkerBase<VectorType, MatrixType, PreconditionerType>;
- IterationWorker(const MatrixType & A,
+ IterationWorker(const MatrixType &A,
const PreconditionerType &preconditioner,
const bool flexible,
VectorMemory<VectorType> &memory,
- VectorType & x)
+ VectorType &x)
: BaseClass(A, preconditioner, flexible, memory, x)
{}
Number next_r_dot_preconditioner_dot_r;
Number previous_beta;
- IterationWorker(const MatrixType & A,
+ IterationWorker(const MatrixType &A,
const PreconditionerType &preconditioner,
const bool flexible,
VectorMemory<VectorType> &memory,
- VectorType & x)
+ VectorType &x)
: IterationWorkerBase<VectorType, MatrixType, PreconditionerType>(
A,
preconditioner,
const unsigned int start_range,
const unsigned int end_range) const
{
- Number * x = this->x.begin();
- Number * r = this->r.begin();
- Number * p = this->p.begin();
- Number * v = this->v.begin();
+ Number *x = this->x.begin();
+ Number *r = this->r.begin();
+ Number *p = this->p.begin();
+ Number *v = this->v.begin();
const Number alpha = this->alpha;
const Number beta = this->beta;
constexpr unsigned int n_lanes = VectorizedArray<Number>::size();
const unsigned int end_range,
std::array<VectorizedArray<Number>, 7> &vectorized_sums) const
{
- const Number * r = this->r.begin();
- const Number * p = this->p.begin();
- const Number * v = this->v.begin();
+ const Number *r = this->r.begin();
+ const Number *p = this->p.begin();
+ const Number *v = this->v.begin();
std::array<VectorizedArray<Number>, 7> my_sums = {};
constexpr unsigned int n_lanes = VectorizedArray<Number>::size();
const unsigned int end_regular =
const unsigned int start_range,
const unsigned int end_range) const
{
- Number * x = this->x.begin() + start_range;
- Number * r = this->r.begin() + start_range;
- Number * p = this->p.begin() + start_range;
- Number * v = this->v.begin() + start_range;
+ Number *x = this->x.begin() + start_range;
+ Number *r = this->r.begin() + start_range;
+ Number *p = this->p.begin() + start_range;
+ Number *v = this->v.begin() + start_range;
const Number alpha = this->alpha;
const Number beta = this->beta;
constexpr unsigned int grain_size = 128;
const unsigned int end_range,
std::array<VectorizedArray<Number>, 7> &vectorized_sums) const
{
- const Number * r = this->r.begin();
- const Number * p = this->p.begin();
- const Number * v = this->v.begin();
+ const Number *r = this->r.begin();
+ const Number *p = this->p.begin();
+ const Number *v = this->v.begin();
std::array<VectorizedArray<Number>, 7> my_sums = {};
constexpr unsigned int grain_size = 128;
Assert(grain_size % VectorizedArray<Number>::size() == 0,
{
const unsigned int end_range = this->x.locally_owned_size();
- Number * x = this->x.begin();
- Number * r = this->r.begin();
- Number * p = this->p.begin();
+ Number *x = this->x.begin();
+ Number *r = this->r.begin();
+ Number *p = this->p.begin();
const Number alpha_plus_previous_alpha_over_beta =
this->alpha + this->previous_alpha / this->beta;
const Number previous_alpha_over_beta =
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
-SolverCG<VectorType>::solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverCG<VectorType>::solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner)
{
using number = typename VectorType::value_type;
template <typename VectorType>
-SolverFlexibleCG<VectorType>::SolverFlexibleCG(SolverControl & cn,
+SolverFlexibleCG<VectorType>::SolverFlexibleCG(SolverControl &cn,
VectorMemory<VectorType> &mem,
const AdditionalData &)
: SolverCG<VectorType>(cn, mem)
/**
* Constructor.
*/
- SolverFIRE(SolverControl & solver_control,
+ SolverFIRE(SolverControl &solver_control,
VectorMemory<VectorType> &vector_memory,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
* Constructor. Use an object of type GrowingVectorMemory as a default to
* allocate memory.
*/
- SolverFIRE(SolverControl & solver_control,
+ SolverFIRE(SolverControl &solver_control,
const AdditionalData &data = AdditionalData());
/**
template <typename PreconditionerType = DiagonalMatrix<VectorType>>
void
solve(const std::function<double(VectorType &, const VectorType &)> &compute,
- VectorType & x,
+ VectorType &x,
const PreconditionerType &inverse_mass_matrix);
/**
*/
template <typename MatrixType, typename PreconditionerType>
void
- solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner);
protected:
template <typename VectorType>
-SolverFIRE<VectorType>::SolverFIRE(SolverControl & solver_control,
+SolverFIRE<VectorType>::SolverFIRE(SolverControl &solver_control,
VectorMemory<VectorType> &vector_memory,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<VectorType>(solver_control, vector_memory)
, additional_data(data)
{}
template <typename VectorType>
-SolverFIRE<VectorType>::SolverFIRE(SolverControl & solver_control,
+SolverFIRE<VectorType>::SolverFIRE(SolverControl &solver_control,
const AdditionalData &data)
: SolverBase<VectorType>(solver_control)
, additional_data(data)
void
SolverFIRE<VectorType>::solve(
const std::function<double(VectorType &, const VectorType &)> &compute,
- VectorType & x,
+ VectorType &x,
const PreconditionerType &inverse_mass_matrix)
{
LogStream::Prefix prefix("FIRE");
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
-SolverFIRE<VectorType>::solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverFIRE<VectorType>::solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner)
{
std::function<double(VectorType &, const VectorType &)> compute_func =
/**
* Constructor.
*/
- SolverGMRES(SolverControl & cn,
+ SolverGMRES(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
* Constructor. Use an object of type GrowingVectorMemory as a default to
*/
template <typename MatrixType, typename PreconditionerType>
void
- solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner);
/**
const boost::signals2::signal<
void(const std::vector<std::complex<double>> &)> &eigenvalues_signal,
const boost::signals2::signal<void(const FullMatrix<double> &)>
- & hessenberg_signal,
+ &hessenberg_signal,
const boost::signals2::signal<void(double)> &cond_signal);
/**
/**
* Constructor.
*/
- SolverFGMRES(SolverControl & cn,
+ SolverFGMRES(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
* Constructor. Use an object of type GrowingVectorMemory as a default to
* allocate memory.
*/
- SolverFGMRES(SolverControl & cn,
+ SolverFGMRES(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
*/
template <typename MatrixType, typename PreconditionerType>
void
- solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner);
private:
template <typename VectorType>
inline VectorType &
TmpVectors<VectorType>::operator()(const unsigned int i,
- const VectorType & temp)
+ const VectorType &temp)
{
AssertIndexRange(i, data.size());
if (data[i] == nullptr)
inline void
solve_triangular(const unsigned int dim,
const FullMatrix<double> &H,
- const Vector<double> & rhs,
- Vector<double> & solution)
+ const Vector<double> &rhs,
+ Vector<double> &solution)
{
for (int i = dim - 1; i >= 0; --i)
{
template <typename VectorType>
-SolverGMRES<VectorType>::SolverGMRES(SolverControl & cn,
+SolverGMRES<VectorType>::SolverGMRES(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<VectorType>(cn, mem)
, additional_data(data)
, solver_control(cn)
template <typename VectorType>
-SolverGMRES<VectorType>::SolverGMRES(SolverControl & cn,
+SolverGMRES<VectorType>::SolverGMRES(SolverControl &cn,
const AdditionalData &data)
: SolverBase<VectorType>(cn)
, additional_data(data)
VectorType> * = nullptr>
void
Tvmult_add(const unsigned int dim,
- const VectorType & vv,
+ const VectorType &vv,
const internal::SolverGMRESImplementation::TmpVectors<VectorType>
- & orthogonal_vectors,
+ &orthogonal_vectors,
Vector<double> &h)
{
for (unsigned int i = 0; i < dim; ++i)
VectorType> * = nullptr>
void
Tvmult_add(const unsigned int dim,
- const VectorType & vv,
+ const VectorType &vv,
const internal::SolverGMRESImplementation::TmpVectors<VectorType>
- & orthogonal_vectors,
+ &orthogonal_vectors,
Vector<double> &h)
{
for (unsigned int b = 0; b < n_blocks(vv); ++b)
subtract_and_norm(
const unsigned int dim,
const internal::SolverGMRESImplementation::TmpVectors<VectorType>
- & orthogonal_vectors,
+ &orthogonal_vectors,
const Vector<double> &h,
- VectorType & vv)
+ VectorType &vv)
{
Assert(dim > 0, ExcInternalError());
subtract_and_norm(
const unsigned int dim,
const internal::SolverGMRESImplementation::TmpVectors<VectorType>
- & orthogonal_vectors,
+ &orthogonal_vectors,
const Vector<double> &h,
- VectorType & vv)
+ VectorType &vv)
{
static constexpr unsigned int n_lanes = VectorizedArray<double>::size();
!is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
double
- sadd_and_norm(VectorType & v,
+ sadd_and_norm(VectorType &v,
const double factor_a,
const VectorType &b,
const double factor_b)
is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
double
- sadd_and_norm(VectorType & v,
+ sadd_and_norm(VectorType &v,
const double factor_a,
const VectorType &w,
const double factor_b)
!is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
void
- add(VectorType & p,
+ add(VectorType &p,
const unsigned int dim,
const Vector<double> &h,
const internal::SolverGMRESImplementation::TmpVectors<VectorType>
- & tmp_vectors,
+ &tmp_vectors,
const bool zero_out)
{
if (zero_out)
is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
void
- add(VectorType & p,
+ add(VectorType &p,
const unsigned int dim,
const Vector<double> &h,
const internal::SolverGMRESImplementation::TmpVectors<VectorType>
- & tmp_vectors,
+ &tmp_vectors,
const bool zero_out)
{
for (unsigned int b = 0; b < n_blocks(p); ++b)
iterated_gram_schmidt(
const LinearAlgebra::OrthogonalizationStrategy orthogonalization_strategy,
const internal::SolverGMRESImplementation::TmpVectors<VectorType>
- & orthogonal_vectors,
+ &orthogonal_vectors,
const unsigned int dim,
const unsigned int accumulated_iterations,
- VectorType & vv,
- Vector<double> & h,
- bool & reorthogonalize,
+ VectorType &vv,
+ Vector<double> &h,
+ bool &reorthogonalize,
const boost::signals2::signal<void(int)> &reorthogonalize_signal =
boost::signals2::signal<void(int)>())
{
const boost::signals2::signal<void(const std::vector<std::complex<double>> &)>
&eigenvalues_signal,
const boost::signals2::signal<void(const FullMatrix<double> &)>
- & hessenberg_signal,
+ &hessenberg_signal,
const boost::signals2::signal<void(double)> &cond_signal)
{
// Avoid copying the Hessenberg matrix if it isn't needed.
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
-SolverGMRES<VectorType>::solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverGMRES<VectorType>::solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner)
{
// TODO:[?] Check, why there are two different start residuals.
//----------------------------------------------------------------------//
template <typename VectorType>
-SolverFGMRES<VectorType>::SolverFGMRES(SolverControl & cn,
+SolverFGMRES<VectorType>::SolverFGMRES(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<VectorType>(cn, mem)
, additional_data(data)
{}
template <typename VectorType>
-SolverFGMRES<VectorType>::SolverFGMRES(SolverControl & cn,
+SolverFGMRES<VectorType>::SolverFGMRES(SolverControl &cn,
const AdditionalData &data)
: SolverBase<VectorType>(cn)
, additional_data(data)
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
-SolverFGMRES<VectorType>::solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverFGMRES<VectorType>::solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner)
{
LogStream::Prefix prefix("FGMRES");
/**
* Constructor.
*/
- SolverIDR(SolverControl & cn,
+ SolverIDR(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
* Constructor. Use an object of type GrowingVectorMemory as a default to
* allocate memory.
*/
- explicit SolverIDR(SolverControl & cn,
+ explicit SolverIDR(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
*/
template <typename MatrixType, typename PreconditionerType>
void
- solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner);
protected:
*/
virtual void
print_vectors(const unsigned int step,
- const VectorType & x,
- const VectorType & r,
- const VectorType & d) const;
+ const VectorType &x,
+ const VectorType &r,
+ const VectorType &d) const;
private:
/**
template <typename VectorType>
inline VectorType &
TmpVectors<VectorType>::operator()(const unsigned int i,
- const VectorType & temp)
+ const VectorType &temp)
{
AssertIndexRange(i, data.size());
if (data[i] == nullptr)
template <typename VectorType>
-SolverIDR<VectorType>::SolverIDR(SolverControl & cn,
+SolverIDR<VectorType>::SolverIDR(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<VectorType>(cn, mem)
, additional_data(data)
{}
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
-SolverIDR<VectorType>::solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverIDR<VectorType>::solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner)
{
LogStream::Prefix prefix("IDR(s)");
/**
* Constructor.
*/
- SolverMinRes(SolverControl & cn,
+ SolverMinRes(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
* Constructor. Use an object of type GrowingVectorMemory as a default to
* allocate memory.
*/
- SolverMinRes(SolverControl & cn,
+ SolverMinRes(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
*/
template <typename MatrixType, typename PreconditionerType>
void
- solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner);
/**
*/
virtual void
print_vectors(const unsigned int step,
- const VectorType & x,
- const VectorType & r,
- const VectorType & d) const;
+ const VectorType &x,
+ const VectorType &r,
+ const VectorType &d) const;
/**
* Within the iteration loop, the square of the residual vector is stored in
#ifndef DOXYGEN
template <typename VectorType>
-SolverMinRes<VectorType>::SolverMinRes(SolverControl & cn,
+SolverMinRes<VectorType>::SolverMinRes(SolverControl &cn,
VectorMemory<VectorType> &mem,
const AdditionalData &)
: SolverBase<VectorType>(cn, mem)
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
-SolverMinRes<VectorType>::solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverMinRes<VectorType>::solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner)
{
LogStream::Prefix prefix("minres");
/**
* Constructor.
*/
- SolverQMRS(SolverControl & cn,
+ SolverQMRS(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
* Constructor. Use an object of type GrowingVectorMemory as a default to
*/
template <typename MatrixType, typename PreconditionerType>
void
- solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner);
/**
*/
virtual void
print_vectors(const unsigned int step,
- const VectorType & x,
- const VectorType & r,
- const VectorType & d) const;
+ const VectorType &x,
+ const VectorType &r,
+ const VectorType &d) const;
protected:
/**
*/
template <typename MatrixType, typename PreconditionerType>
IterationResult
- iterate(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ iterate(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner,
- VectorType & r,
- VectorType & u,
- VectorType & q,
- VectorType & t,
- VectorType & d);
+ VectorType &r,
+ VectorType &u,
+ VectorType &q,
+ VectorType &t,
+ VectorType &d);
/**
* Number of the current iteration (accumulated over restarts)
template <typename VectorType>
-SolverQMRS<VectorType>::SolverQMRS(SolverControl & cn,
+SolverQMRS<VectorType>::SolverQMRS(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<VectorType>(cn, mem)
, additional_data(data)
, step(0)
{}
template <typename VectorType>
-SolverQMRS<VectorType>::SolverQMRS(SolverControl & cn,
+SolverQMRS<VectorType>::SolverQMRS(SolverControl &cn,
const AdditionalData &data)
: SolverBase<VectorType>(cn)
, additional_data(data)
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
-SolverQMRS<VectorType>::solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverQMRS<VectorType>::solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner)
{
LogStream::Prefix prefix("SQMR");
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
typename SolverQMRS<VectorType>::IterationResult
-SolverQMRS<VectorType>::iterate(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverQMRS<VectorType>::iterate(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner,
- VectorType & r,
- VectorType & u,
- VectorType & q,
- VectorType & t,
- VectorType & d)
+ VectorType &r,
+ VectorType &u,
+ VectorType &q,
+ VectorType &t,
+ VectorType &d)
{
SolverControl::State state = SolverControl::iterate;
/**
* Constructor.
*/
- SolverRelaxation(SolverControl & cn,
+ SolverRelaxation(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
*/
template <typename MatrixType, typename RelaxationType>
void
- solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const RelaxationType &R);
};
template <typename VectorType>
template <typename MatrixType, typename RelaxationType>
void
-SolverRelaxation<VectorType>::solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverRelaxation<VectorType>::solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const RelaxationType &R)
{
GrowingVectorMemory<VectorType> mem;
// Memory allocation
typename VectorMemory<VectorType>::Pointer Vr(mem);
- VectorType & r = *Vr;
+ VectorType &r = *Vr;
r.reinit(x);
typename VectorMemory<VectorType>::Pointer Vd(mem);
- VectorType & d = *Vd;
+ VectorType &d = *Vd;
d.reinit(x);
LogStream::Prefix prefix("Relaxation");
/**
* Constructor.
*/
- SolverRichardson(SolverControl & cn,
+ SolverRichardson(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data = AdditionalData());
+ const AdditionalData &data = AdditionalData());
/**
* Constructor. Use an object of type GrowingVectorMemory as a default to
* allocate memory.
*/
- SolverRichardson(SolverControl & cn,
+ SolverRichardson(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
*/
template <typename MatrixType, typename PreconditionerType>
void
- solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner);
/**
*/
template <typename MatrixType, typename PreconditionerType>
void
- Tsolve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+ Tsolve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner);
/**
*/
virtual void
print_vectors(const unsigned int step,
- const VectorType & x,
- const VectorType & r,
- const VectorType & d) const;
+ const VectorType &x,
+ const VectorType &r,
+ const VectorType &d) const;
protected:
/**
template <typename VectorType>
-SolverRichardson<VectorType>::SolverRichardson(SolverControl & cn,
+SolverRichardson<VectorType>::SolverRichardson(SolverControl &cn,
VectorMemory<VectorType> &mem,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<VectorType>(cn, mem)
, additional_data(data)
{}
template <typename VectorType>
-SolverRichardson<VectorType>::SolverRichardson(SolverControl & cn,
+SolverRichardson<VectorType>::SolverRichardson(SolverControl &cn,
const AdditionalData &data)
: SolverBase<VectorType>(cn)
, additional_data(data)
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
-SolverRichardson<VectorType>::solve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverRichardson<VectorType>::solve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner)
{
SolverControl::State conv = SolverControl::iterate;
template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
-SolverRichardson<VectorType>::Tsolve(const MatrixType & A,
- VectorType & x,
- const VectorType & b,
+SolverRichardson<VectorType>::Tsolve(const MatrixType &A,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &preconditioner)
{
SolverControl::State conv = SolverControl::iterate;
*/
template <class Matrix, class Preconditioner>
void
- solve(const Matrix & A,
- VectorType & x,
- const VectorType & b,
+ solve(const Matrix &A,
+ VectorType &x,
+ const VectorType &b,
const Preconditioner &precond) const;
/**
template <typename VectorType>
SolverSelector<VectorType>::SolverSelector(const std::string &name,
- SolverControl & solver_control)
+ SolverControl &solver_control)
: solver_name(name)
, control(&solver_control)
{}
template <typename VectorType>
template <class Matrix, class Preconditioner>
void
-SolverSelector<VectorType>::solve(const Matrix & A,
- VectorType & x,
- const VectorType & b,
+SolverSelector<VectorType>::solve(const Matrix &A,
+ VectorType &x,
+ const VectorType &b,
const Preconditioner &precond) const
{
if (solver_name == "richardson")
template <typename number>
template <class OutVector, class InVector>
inline void
-SparseLUDecomposition<number>::vmult_add(OutVector & dst,
+SparseLUDecomposition<number>::vmult_add(OutVector &dst,
const InVector &src) const
{
OutVector tmp;
template <typename number>
template <class OutVector, class InVector>
inline void
-SparseLUDecomposition<number>::Tvmult_add(OutVector & dst,
+SparseLUDecomposition<number>::Tvmult_add(OutVector &dst,
const InVector &src) const
{
OutVector tmp;
// pattern as the input matrix
if (&this->get_sparsity_pattern() == &matrix.get_sparsity_pattern())
{
- const somenumber * input_ptr = matrix.val.get();
- number * this_ptr = this->val.get();
+ const somenumber *input_ptr = matrix.val.get();
+ number *this_ptr = this->val.get();
const number *const end_ptr = this_ptr + this->n_nonzero_elements();
if (std::is_same_v<somenumber, number> == true)
std::memcpy(this_ptr,
*/
template <class Matrix>
void
- initialize(const Matrix & matrix,
+ initialize(const Matrix &matrix,
const AdditionalData additional_data = AdditionalData());
/**
*/
template <class Matrix>
void
- solve(const Matrix & matrix,
+ solve(const Matrix &matrix,
Vector<double> &rhs_and_solution,
const bool transpose = false);
*/
template <class Matrix>
void
- solve(const Matrix & matrix,
+ solve(const Matrix &matrix,
Vector<std::complex<double>> &rhs_and_solution,
const bool transpose = false);
*/
template <class Matrix>
void
- solve(const Matrix & matrix,
+ solve(const Matrix &matrix,
BlockVector<double> &rhs_and_solution,
const bool transpose = false);
*/
template <class Matrix>
void
- solve(const Matrix & matrix,
+ solve(const Matrix &matrix,
BlockVector<std::complex<double>> &rhs_and_solution,
const bool transpose = false);
template <typename somenumber>
void
initialize(const SparseMatrix<somenumber> &matrix,
- const AdditionalData & parameters = AdditionalData());
+ const AdditionalData ¶meters = AdditionalData());
/**
* Apply the incomplete decomposition, i.e. do one forward-backward step
template <typename somenumber>
void
SparseILU<number>::initialize(const SparseMatrix<somenumber> &matrix,
- const AdditionalData & data)
+ const AdditionalData &data)
{
SparseLUDecomposition<number>::initialize(matrix, data);
// in the following, we implement algorithm 10.4 in the book by Saad by
// translating in essence the algorithm given at the end of section 10.3.2,
// using the names of variables used there
- const SparsityPattern & sparsity = this->get_sparsity_pattern();
+ const SparsityPattern &sparsity = this->get_sparsity_pattern();
const std::size_t *const ia = sparsity.rowstart.get();
const size_type *const ja = sparsity.colnums.get();
template <typename number>
template <typename somenumber>
void
-SparseILU<number>::vmult(Vector<somenumber> & dst,
+SparseILU<number>::vmult(Vector<somenumber> &dst,
const Vector<somenumber> &src) const
{
Assert(dst.size() == src.size(),
template <typename number>
template <typename somenumber>
void
-SparseILU<number>::Tvmult(Vector<somenumber> & dst,
+SparseILU<number>::Tvmult(Vector<somenumber> &dst,
const Vector<somenumber> &src) const
{
Assert(dst.size() == src.size(),
this->prebuilt_lower_bound[row];
const somenumber dst_row = dst(row);
- const number * luval = this->SparseMatrix<number>::val.get() +
+ const number *luval = this->SparseMatrix<number>::val.get() +
(first_after_diagonal - column_numbers);
for (const size_type *col = first_after_diagonal; col != rowend;
++col, ++luval)
this->prebuilt_lower_bound[row];
const somenumber dst_row = dst(row);
- const number * luval =
+ const number *luval =
this->SparseMatrix<number>::val.get() + (rowstart - column_numbers);
for (const size_type *col = rowstart; col != first_after_diagonal;
++col, ++luval)
template <typename number2>
void
set(const std::vector<size_type> &indices,
- const FullMatrix<number2> & full_matrix,
+ const FullMatrix<number2> &full_matrix,
const bool elide_zero_values = false);
/**
void
set(const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- const FullMatrix<number2> & full_matrix,
+ const FullMatrix<number2> &full_matrix,
const bool elide_zero_values = false);
/**
void
set(const size_type row,
const std::vector<size_type> &col_indices,
- const std::vector<number2> & values,
+ const std::vector<number2> &values,
const bool elide_zero_values = false);
/**
set(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool elide_zero_values = false);
/**
template <typename number2>
void
add(const std::vector<size_type> &indices,
- const FullMatrix<number2> & full_matrix,
+ const FullMatrix<number2> &full_matrix,
const bool elide_zero_values = true);
/**
void
add(const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- const FullMatrix<number2> & full_matrix,
+ const FullMatrix<number2> &full_matrix,
const bool elide_zero_values = true);
/**
void
add(const size_type row,
const std::vector<size_type> &col_indices,
- const std::vector<number2> & values,
+ const std::vector<number2> &values,
const bool elide_zero_values = true);
/**
add(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool elide_zero_values = true,
const bool col_indices_are_sorted = false);
*/
template <typename somenumber>
somenumber
- residual(Vector<somenumber> & dst,
+ residual(Vector<somenumber> &dst,
const Vector<somenumber> &x,
const Vector<somenumber> &b) const;
*/
template <typename numberB, typename numberC>
void
- mmult(SparseMatrix<numberC> & C,
+ mmult(SparseMatrix<numberC> &C,
const SparseMatrix<numberB> &B,
- const Vector<number> & V = Vector<number>(),
+ const Vector<number> &V = Vector<number>(),
const bool rebuild_sparsity_pattern = true) const;
/**
*/
template <typename numberB, typename numberC>
void
- Tmmult(SparseMatrix<numberC> & C,
+ Tmmult(SparseMatrix<numberC> &C,
const SparseMatrix<numberB> &B,
- const Vector<number> & V = Vector<number>(),
+ const Vector<number> &V = Vector<number>(),
const bool rebuild_sparsity_pattern = true) const;
/** @} */
*/
template <typename somenumber>
void
- precondition_Jacobi(Vector<somenumber> & dst,
+ precondition_Jacobi(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number omega = 1.) const;
*/
template <typename somenumber>
void
- precondition_SSOR(Vector<somenumber> & dst,
- const Vector<somenumber> & src,
+ precondition_SSOR(Vector<somenumber> &dst,
+ const Vector<somenumber> &src,
const number omega = 1.,
const std::vector<std::size_t> &pos_right_of_diagonal =
std::vector<std::size_t>()) const;
*/
template <typename somenumber>
void
- precondition_SOR(Vector<somenumber> & dst,
+ precondition_SOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number omega = 1.) const;
*/
template <typename somenumber>
void
- precondition_TSOR(Vector<somenumber> & dst,
+ precondition_TSOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number omega = 1.) const;
*/
template <typename somenumber>
void
- PSOR(Vector<somenumber> & v,
+ PSOR(Vector<somenumber> &v,
const std::vector<size_type> &permutation,
const std::vector<size_type> &inverse_permutation,
const number omega = 1.) const;
*/
template <typename somenumber>
void
- TPSOR(Vector<somenumber> & v,
+ TPSOR(Vector<somenumber> &v,
const std::vector<size_type> &permutation,
const std::vector<size_type> &inverse_permutation,
const number omega = 1.) const;
*/
template <typename somenumber>
void
- Jacobi_step(Vector<somenumber> & v,
+ Jacobi_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number omega = 1.) const;
*/
template <typename somenumber>
void
- SOR_step(Vector<somenumber> & v,
+ SOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number omega = 1.) const;
*/
template <typename somenumber>
void
- TSOR_step(Vector<somenumber> & v,
+ TSOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number omega = 1.) const;
*/
template <typename somenumber>
void
- SSOR_step(Vector<somenumber> & v,
+ SSOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number omega = 1.) const;
/** @} */
* applied to a large matrix!
*/
void
- print_formatted(std::ostream & out,
+ print_formatted(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const unsigned int width = 0,
- const char * zero_string = " ",
+ const char *zero_string = " ",
const double denominator = 1.) const;
/**
* </code>
*/
void
- print_as_numpy_arrays(std::ostream & out,
+ print_as_numpy_arrays(std::ostream &out,
const unsigned int precision = 9) const;
/**
template <typename number2>
inline void
SparseMatrix<number>::set(const std::vector<size_type> &indices,
- const FullMatrix<number2> & values,
+ const FullMatrix<number2> &values,
const bool elide_zero_values)
{
Assert(indices.size() == values.m(),
inline void
SparseMatrix<number>::set(const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- const FullMatrix<number2> & values,
+ const FullMatrix<number2> &values,
const bool elide_zero_values)
{
Assert(row_indices.size() == values.m(),
inline void
SparseMatrix<number>::set(const size_type row,
const std::vector<size_type> &col_indices,
- const std::vector<number2> & values,
+ const std::vector<number2> &values,
const bool elide_zero_values)
{
Assert(col_indices.size() == values.size(),
template <typename number2>
inline void
SparseMatrix<number>::add(const std::vector<size_type> &indices,
- const FullMatrix<number2> & values,
+ const FullMatrix<number2> &values,
const bool elide_zero_values)
{
Assert(indices.size() == values.m(),
inline void
SparseMatrix<number>::add(const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- const FullMatrix<number2> & values,
+ const FullMatrix<number2> &values,
const bool elide_zero_values)
{
Assert(row_indices.size() == values.m(),
inline void
SparseMatrix<number>::add(const size_type row,
const std::vector<size_type> &col_indices,
- const std::vector<number2> & values,
+ const std::vector<number2> &values,
const bool elide_zero_values)
{
Assert(col_indices.size() == values.size(),
Assert(cols != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
- number * val_ptr = val.get();
+ number *val_ptr = val.get();
const number *const end_ptr = val.get() + cols->n_nonzero_elements();
while (val_ptr != end_ptr)
const number factor_inv = number(1.) / factor;
- number * val_ptr = val.get();
+ number *val_ptr = val.get();
const number *const end_ptr = val.get() + cols->n_nonzero_elements();
while (val_ptr != end_ptr)
template <typename number>
- inline Accessor<number, false>::Accessor(MatrixType * matrix,
+ inline Accessor<number, false>::Accessor(MatrixType *matrix,
const std::size_t index)
: SparsityPatternIterators::Accessor(&matrix->get_sparsity_pattern(), index)
, matrix(matrix)
template <typename number, bool Constness>
- inline Iterator<number, Constness>::Iterator(MatrixType * matrix,
+ inline Iterator<number, Constness>::Iterator(MatrixType *matrix,
const std::size_t index)
: accessor(matrix, index)
{}
template <typename number>
SparseMatrix<number>::SparseMatrix(const SparsityPattern &c,
- const IdentityMatrix & id)
+ const IdentityMatrix &id)
: cols(nullptr, "SparseMatrix")
, val(nullptr)
, max_len(0)
number *val_ptr = &val[cols->rowstart[row]];
if (m() == n())
++val_ptr;
- const size_type * colnum_ptr = &cols->colnums[cols->rowstart[row] + 1];
+ const size_type *colnum_ptr = &cols->colnums[cols->rowstart[row] + 1];
const number *const val_end_of_row = &val[cols->rowstart[row + 1]];
// treat lower left triangle
Assert(val != nullptr, ExcNotInitialized());
Assert(cols == matrix.cols, ExcDifferentSparsityPatterns());
- number * val_ptr = val.get();
- const somenumber * matrix_ptr = matrix.val.get();
+ number *val_ptr = val.get();
+ const somenumber *matrix_ptr = matrix.val.get();
const number *const end_ptr = val.get() + cols->n_nonzero_elements();
while (val_ptr != end_ptr)
void
vmult_on_subrange(const size_type begin_row,
const size_type end_row,
- const number * values,
+ const number *values,
const std::size_t *rowstart,
- const size_type * colnums,
- const InVector & src,
- OutVector & dst,
+ const size_type *colnums,
+ const InVector &src,
+ OutVector &dst,
const bool add)
{
- const number * val_ptr = &values[rowstart[begin_row]];
- const size_type * colnum_ptr = &colnums[rowstart[begin_row]];
+ const number *val_ptr = &values[rowstart[begin_row]];
+ const size_type *colnum_ptr = &colnums[rowstart[begin_row]];
typename OutVector::iterator dst_ptr = dst.begin() + begin_row;
if (add == false)
SparseMatrix<number>::add(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool elide_zero_values,
const bool col_indices_are_sorted)
{
const size_type *this_cols = &cols->colnums[cols->rowstart[row]];
const size_type row_length_1 = cols->row_length(row) - 1;
- number * val_ptr = &val[cols->rowstart[row]];
+ number *val_ptr = &val[cols->rowstart[row]];
if (m() == n())
{
SparseMatrix<number>::set(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool elide_zero_values)
{
Assert(cols != nullptr, ExcNeedsSparsityPattern());
// First, search all the indices to find
// out which values we actually need to
// set.
- const size_type * my_cols = cols->colnums.get();
+ const size_type *my_cols = cols->colnums.get();
std::size_t index = cols->rowstart[row], next_index = index;
const std::size_t next_row_index = cols->rowstart[row + 1];
typename InVector::value_type
matrix_norm_sqr_on_subrange(const size_type begin_row,
const size_type end_row,
- const number * values,
+ const number *values,
const std::size_t *rowstart,
- const size_type * colnums,
- const InVector & v)
+ const size_type *colnums,
+ const InVector &v)
{
typename InVector::value_type norm_sqr = 0.;
typename InVector::value_type
matrix_scalar_product_on_subrange(const size_type begin_row,
const size_type end_row,
- const number * values,
+ const number *values,
const std::size_t *rowstart,
- const size_type * colnums,
- const InVector & u,
- const InVector & v)
+ const size_type *colnums,
+ const InVector &u,
+ const InVector &v)
{
typename InVector::value_type norm_sqr = 0.;
template <typename number>
template <typename numberB, typename numberC>
void
-SparseMatrix<number>::mmult(SparseMatrix<numberC> & C,
+SparseMatrix<number>::mmult(SparseMatrix<numberC> &C,
const SparseMatrix<numberB> &B,
- const Vector<number> & V,
+ const Vector<number> &V,
const bool rebuild_sparsity_C) const
{
const bool use_vector = V.size() == n() ? true : false;
// elements in that row in B.
for (size_type i = 0; i < C.m(); ++i)
{
- const size_type * rows = &sp_A.colnums[sp_A.rowstart[i]];
+ const size_type *rows = &sp_A.colnums[sp_A.rowstart[i]];
const size_type *const end_rows = &sp_A.colnums[sp_A.rowstart[i + 1]];
for (; rows != end_rows; ++rows)
{
// now the innermost loop that goes over all the elements in row
// 'col' of matrix B. Cache the elements, and then write them into C
// at once
- numberC * new_ptr = new_entries.data();
+ numberC *new_ptr = new_entries.data();
const numberB *B_val_ptr =
&B.val[new_cols - &sp_B.colnums[sp_B.rowstart[0]]];
const numberB *const end_cols = &B.val[sp_B.rowstart[col + 1]];
template <typename number>
template <typename numberB, typename numberC>
void
-SparseMatrix<number>::Tmmult(SparseMatrix<numberC> & C,
+SparseMatrix<number>::Tmmult(SparseMatrix<numberC> &C,
const SparseMatrix<numberB> &B,
- const Vector<number> & V,
+ const Vector<number> &V,
const bool rebuild_sparsity_C) const
{
const bool use_vector = V.size() == m() ? true : false;
// elements in that row in B.
for (size_type i = 0; i < m(); ++i)
{
- const size_type * rows = &sp_A.colnums[sp_A.rowstart[i]];
+ const size_type *rows = &sp_A.colnums[sp_A.rowstart[i]];
const size_type *const end_rows = &sp_A.colnums[sp_A.rowstart[i + 1]];
- const size_type * new_cols = &sp_B.colnums[sp_B.rowstart[i]];
+ const size_type *new_cols = &sp_B.colnums[sp_B.rowstart[i]];
if (sp_B.n_rows() == sp_B.n_cols())
++new_cols;
// now the innermost loop that goes over all the elements in row
// 'col' of matrix B. Cache the elements, and then write them into C
// at once
- numberC * new_ptr = new_entries.data();
+ numberC *new_ptr = new_entries.data();
const numberB *B_val_ptr =
&B.val[new_cols - &sp_B.colnums[sp_B.rowstart[0]]];
for (; B_val_ptr != end_cols; ++B_val_ptr)
typename OutVector::value_type
residual_sqr_on_subrange(const size_type begin_row,
const size_type end_row,
- const number * values,
+ const number *values,
const std::size_t *rowstart,
- const size_type * colnums,
- const InVector & u,
- const InVector & b,
- OutVector & dst)
+ const size_type *colnums,
+ const InVector &u,
+ const InVector &b,
+ OutVector &dst)
{
typename OutVector::value_type norm_sqr = 0.;
template <typename number>
template <typename somenumber>
somenumber
-SparseMatrix<number>::residual(Vector<somenumber> & dst,
+SparseMatrix<number>::residual(Vector<somenumber> &dst,
const Vector<somenumber> &u,
const Vector<somenumber> &b) const
{
template <typename number>
template <typename somenumber>
void
-SparseMatrix<number>::precondition_Jacobi(Vector<somenumber> & dst,
+SparseMatrix<number>::precondition_Jacobi(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number omega) const
{
internal::SparseMatrixImplementation::AssertNoZerosOnDiagonal(*this);
const size_type n = src.size();
- somenumber * dst_ptr = dst.begin();
- const somenumber * src_ptr = src.begin();
+ somenumber *dst_ptr = dst.begin();
+ const somenumber *src_ptr = src.begin();
const std::size_t *rowstart_ptr = cols->rowstart.get();
// optimize the following loop for
template <typename somenumber>
void
SparseMatrix<number>::precondition_SSOR(
- Vector<somenumber> & dst,
- const Vector<somenumber> & src,
+ Vector<somenumber> &dst,
+ const Vector<somenumber> &src,
const number omega,
const std::vector<std::size_t> &pos_right_of_diagonal) const
{
const size_type n = src.size();
const std::size_t *rowstart_ptr = cols->rowstart.get();
- somenumber * dst_ptr = &dst(0);
+ somenumber *dst_ptr = &dst(0);
// case when we have stored the position
// just right of the diagonal (then we
template <typename number>
template <typename somenumber>
void
-SparseMatrix<number>::precondition_SOR(Vector<somenumber> & dst,
+SparseMatrix<number>::precondition_SOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number omega) const
{
template <typename number>
template <typename somenumber>
void
-SparseMatrix<number>::precondition_TSOR(Vector<somenumber> & dst,
+SparseMatrix<number>::precondition_TSOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number omega) const
{
template <typename number>
template <typename somenumber>
void
-SparseMatrix<number>::PSOR(Vector<somenumber> & dst,
+SparseMatrix<number>::PSOR(Vector<somenumber> &dst,
const std::vector<size_type> &permutation,
const std::vector<size_type> &inverse_permutation,
const number omega) const
template <typename number>
template <typename somenumber>
void
-SparseMatrix<number>::TPSOR(Vector<somenumber> & dst,
+SparseMatrix<number>::TPSOR(Vector<somenumber> &dst,
const std::vector<size_type> &permutation,
const std::vector<size_type> &inverse_permutation,
const number omega) const
template <typename number>
template <typename somenumber>
void
-SparseMatrix<number>::Jacobi_step(Vector<somenumber> & v,
+SparseMatrix<number>::Jacobi_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number omega) const
{
template <typename number>
template <typename somenumber>
void
-SparseMatrix<number>::SOR_step(Vector<somenumber> & v,
+SparseMatrix<number>::SOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number omega) const
{
template <typename number>
template <typename somenumber>
void
-SparseMatrix<number>::TSOR_step(Vector<somenumber> & v,
+SparseMatrix<number>::TSOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number omega) const
{
template <typename number>
template <typename somenumber>
void
-SparseMatrix<number>::SSOR_step(Vector<somenumber> & v,
+SparseMatrix<number>::SSOR_step(Vector<somenumber> &v,
const Vector<somenumber> &b,
const number omega) const
{
template <typename number>
void
-SparseMatrix<number>::print_formatted(std::ostream & out,
+SparseMatrix<number>::print_formatted(std::ostream &out,
const unsigned int precision,
const bool scientific,
const unsigned int width_,
- const char * zero_string,
+ const char *zero_string,
const double denominator) const
{
Assert(cols != nullptr, ExcNeedsSparsityPattern());
template <typename number>
void
-SparseMatrix<number>::print_as_numpy_arrays(std::ostream & out,
+SparseMatrix<number>::print_as_numpy_arrays(std::ostream &out,
const unsigned int precision) const
{
AssertThrow(out.fail() == false, ExcIO());
template <typename number>
-void SparseMatrix<number>::compress(VectorOperation::values)
+void
+SparseMatrix<number>::compress(VectorOperation::values)
{}
* printed as well.
*/
void
- compute_statistics(size_type & used,
- size_type & allocated,
- size_type & reserved,
+ compute_statistics(size_type &used,
+ size_type &allocated,
+ size_type &reserved,
std::vector<size_type> &used_by_line,
const bool compute_by_line) const;
/** @} */
template <typename number2>
void
add(const std::vector<size_type> &indices,
- const FullMatrix<number2> & full_matrix,
+ const FullMatrix<number2> &full_matrix,
const bool elide_zero_values = true);
/**
void
add(const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- const FullMatrix<number2> & full_matrix,
+ const FullMatrix<number2> &full_matrix,
const bool elide_zero_values = true);
/**
void
add(const size_type row,
const std::vector<size_type> &col_indices,
- const std::vector<number2> & values,
+ const std::vector<number2> &values,
const bool elide_zero_values = true);
/**
add(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool elide_zero_values = true,
const bool col_indices_are_sorted = false);
*/
template <typename somenumber>
void
- precondition_Jacobi(Vector<somenumber> & dst,
+ precondition_Jacobi(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number omega = 1.) const;
*/
template <typename somenumber>
void
- precondition_SSOR(Vector<somenumber> & dst,
- const Vector<somenumber> & src,
+ precondition_SSOR(Vector<somenumber> &dst,
+ const Vector<somenumber> &src,
const number om = 1.,
const std::vector<std::size_t> &pos_right_of_diagonal =
std::vector<std::size_t>()) const;
*/
template <typename somenumber>
void
- precondition_SOR(Vector<somenumber> & dst,
+ precondition_SOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om = 1.) const;
*/
template <typename somenumber>
void
- precondition_TSOR(Vector<somenumber> & dst,
+ precondition_TSOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om = 1.) const;
* large matrix!
*/
void
- print_formatted(std::ostream & out,
+ print_formatted(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const unsigned int width = 0,
- const char * zero_string = " ",
+ const char *zero_string = " ",
const double denominator = 1.) const;
/**
*/
template <typename somenumber>
void
- threaded_vmult(Vector<somenumber> & dst,
+ threaded_vmult(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const size_type begin_row,
const size_type end_row) const;
threaded_matrix_norm_square(const Vector<somenumber> &v,
const size_type begin_row,
const size_type end_row,
- somenumber * partial_sum) const;
+ somenumber *partial_sum) const;
/**
* Version of @p matrix_scalar_product which only performs its actions on
const Vector<somenumber> &v,
const size_type begin_row,
const size_type end_row,
- somenumber * partial_sum) const;
+ somenumber *partial_sum) const;
/**
* Number of columns. This is used to check vector dimensions only.
template <typename number>
inline SparseMatrixEZ<number>::Entry::Entry(const size_type column,
- const number & value)
+ const number &value)
: column(column)
, value(value)
{}
AssertIndexRange(row, m());
AssertIndexRange(col, n());
- const RowInfo & r = row_info[row];
+ const RowInfo &r = row_info[row];
const size_type end = r.start + r.length;
for (size_type i = r.start; i < end; ++i)
{
AssertIndexRange(row, m());
AssertIndexRange(col, n());
- RowInfo & r = row_info[row];
+ RowInfo &r = row_info[row];
const size_type end = r.start + r.length;
size_type i = r.start;
template <typename number2>
void
SparseMatrixEZ<number>::add(const std::vector<size_type> &indices,
- const FullMatrix<number2> & full_matrix,
+ const FullMatrix<number2> &full_matrix,
const bool elide_zero_values)
{
// TODO: This function can surely be made more efficient
void
SparseMatrixEZ<number>::add(const std::vector<size_type> &row_indices,
const std::vector<size_type> &col_indices,
- const FullMatrix<number2> & full_matrix,
+ const FullMatrix<number2> &full_matrix,
const bool elide_zero_values)
{
// TODO: This function can surely be made more efficient
void
SparseMatrixEZ<number>::add(const size_type row,
const std::vector<size_type> &col_indices,
- const std::vector<number2> & values,
+ const std::vector<number2> &values,
const bool elide_zero_values)
{
// TODO: This function can surely be made more efficient
SparseMatrixEZ<number>::add(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const number2 * values,
+ const number2 *values,
const bool elide_zero_values,
const bool /*col_indices_are_sorted*/)
{
template <typename number>
template <typename somenumber>
void
-SparseMatrixEZ<number>::vmult(Vector<somenumber> & dst,
+SparseMatrixEZ<number>::vmult(Vector<somenumber> &dst,
const Vector<somenumber> &src) const
{
Assert(m() == dst.size(), ExcDimensionMismatch(m(), dst.size()));
const size_type end_row = row_info.size();
for (size_type row = 0; row < end_row; ++row)
{
- const RowInfo & ri = row_info[row];
+ const RowInfo &ri = row_info[row];
typename std::vector<Entry>::const_iterator entry =
data.begin() + ri.start;
double s = 0.;
template <typename number>
template <typename somenumber>
void
-SparseMatrixEZ<number>::Tvmult(Vector<somenumber> & dst,
+SparseMatrixEZ<number>::Tvmult(Vector<somenumber> &dst,
const Vector<somenumber> &src) const
{
dst = 0.;
template <typename number>
template <typename somenumber>
void
-SparseMatrixEZ<number>::vmult_add(Vector<somenumber> & dst,
+SparseMatrixEZ<number>::vmult_add(Vector<somenumber> &dst,
const Vector<somenumber> &src) const
{
Assert(m() == dst.size(), ExcDimensionMismatch(m(), dst.size()));
const size_type end_row = row_info.size();
for (size_type row = 0; row < end_row; ++row)
{
- const RowInfo & ri = row_info[row];
+ const RowInfo &ri = row_info[row];
typename std::vector<Entry>::const_iterator entry =
data.begin() + ri.start;
double s = 0.;
template <typename number>
template <typename somenumber>
void
-SparseMatrixEZ<number>::Tvmult_add(Vector<somenumber> & dst,
+SparseMatrixEZ<number>::Tvmult_add(Vector<somenumber> &dst,
const Vector<somenumber> &src) const
{
Assert(n() == dst.size(), ExcDimensionMismatch(n(), dst.size()));
const size_type end_row = row_info.size();
for (size_type row = 0; row < end_row; ++row)
{
- const RowInfo & ri = row_info[row];
+ const RowInfo &ri = row_info[row];
typename std::vector<Entry>::const_iterator entry =
data.begin() + ri.start;
for (unsigned short i = 0; i < ri.length; ++i, ++entry)
template <typename number>
template <typename somenumber>
void
-SparseMatrixEZ<number>::precondition_Jacobi(Vector<somenumber> & dst,
+SparseMatrixEZ<number>::precondition_Jacobi(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om) const
{
Assert(dst.size() == n(), ExcDimensionMismatch(dst.size(), n()));
Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
- somenumber * dst_ptr = dst.begin();
- const somenumber * src_ptr = src.begin();
+ somenumber *dst_ptr = dst.begin();
+ const somenumber *src_ptr = src.begin();
typename std::vector<RowInfo>::const_iterator ri = row_info.begin();
const typename std::vector<RowInfo>::const_iterator end = row_info.end();
template <typename number>
template <typename somenumber>
void
-SparseMatrixEZ<number>::precondition_SOR(Vector<somenumber> & dst,
+SparseMatrixEZ<number>::precondition_SOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om) const
{
Assert(dst.size() == n(), ExcDimensionMismatch(dst.size(), n()));
Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
- somenumber * dst_ptr = dst.begin();
- const somenumber * src_ptr = src.begin();
+ somenumber *dst_ptr = dst.begin();
+ const somenumber *src_ptr = src.begin();
typename std::vector<RowInfo>::const_iterator ri = row_info.begin();
const typename std::vector<RowInfo>::const_iterator end = row_info.end();
template <typename number>
template <typename somenumber>
void
-SparseMatrixEZ<number>::precondition_TSOR(Vector<somenumber> & dst,
+SparseMatrixEZ<number>::precondition_TSOR(Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om) const
{
Assert(dst.size() == n(), ExcDimensionMismatch(dst.size(), n()));
Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
- somenumber * dst_ptr = dst.begin() + dst.size() - 1;
+ somenumber *dst_ptr = dst.begin() + dst.size() - 1;
const somenumber *src_ptr = src.begin() + src.size() - 1;
typename std::vector<RowInfo>::const_reverse_iterator ri = row_info.rbegin();
const typename std::vector<RowInfo>::const_reverse_iterator end =
template <typename somenumber>
void
SparseMatrixEZ<number>::precondition_SSOR(
- Vector<somenumber> & dst,
+ Vector<somenumber> &dst,
const Vector<somenumber> &src,
const number om,
const std::vector<std::size_t> &) const
Assert(dst.size() == n(), ExcDimensionMismatch(dst.size(), n()));
Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
- somenumber * dst_ptr = dst.begin();
- const somenumber * src_ptr = src.begin();
+ somenumber *dst_ptr = dst.begin();
+ const somenumber *src_ptr = src.begin();
typename std::vector<RowInfo>::const_iterator ri;
const typename std::vector<RowInfo>::const_iterator end = row_info.end();
template <typename number>
void
-SparseMatrixEZ<number>::compute_statistics(size_type & used,
- size_type & allocated,
- size_type & reserved,
+SparseMatrixEZ<number>::compute_statistics(size_type &used,
+ size_type &allocated,
+ size_type &reserved,
std::vector<size_type> &used_by_line,
const bool full) const
{
template <typename number>
void
-SparseMatrixEZ<number>::print_formatted(std::ostream & out,
+SparseMatrixEZ<number>::print_formatted(std::ostream &out,
const unsigned int precision,
const bool scientific,
const unsigned int width_,
- const char * zero_string,
+ const char *zero_string,
const double denominator) const
{
AssertThrow(out.fail() == false, ExcIO());
typename SparseMatrixType2,
typename SparsityPatternType2>
void
- restrict_to_serial_sparse_matrix(const SparseMatrixType & sparse_matrix_in,
+ restrict_to_serial_sparse_matrix(const SparseMatrixType &sparse_matrix_in,
const SparsityPatternType &sparsity_pattern,
- const IndexSet & requested_is,
- SparseMatrixType2 & system_matrix_out,
+ const IndexSet &requested_is,
+ SparseMatrixType2 &system_matrix_out,
SparsityPatternType2 &sparsity_pattern_out);
/**
typename SparseMatrixType2,
typename SparsityPatternType2>
void
- restrict_to_serial_sparse_matrix(const SparseMatrixType & sparse_matrix_in,
+ restrict_to_serial_sparse_matrix(const SparseMatrixType &sparse_matrix_in,
const SparsityPatternType &sparsity_pattern,
- const IndexSet & index_set_0,
- const IndexSet & index_set_1,
- SparseMatrixType2 & system_matrix_out,
+ const IndexSet &index_set_0,
+ const IndexSet &index_set_1,
+ SparseMatrixType2 &system_matrix_out,
SparsityPatternType2 &sparsity_pattern_out);
/**
typename SparsityPatternType,
typename Number>
void
- restrict_to_cells(const SparseMatrixType & system_matrix,
- const SparsityPatternType & sparsity_pattern,
+ restrict_to_cells(const SparseMatrixType &system_matrix,
+ const SparsityPatternType &sparsity_pattern,
const DoFHandler<dim, spacedim> &dof_handler,
std::vector<FullMatrix<Number>> &blocks);
typename Number>
void
restrict_to_full_matrices(
- const SparseMatrixType & sparse_matrix_in,
- const SparsityPatternType & sparsity_pattern,
+ const SparseMatrixType &sparse_matrix_in,
+ const SparsityPatternType &sparsity_pattern,
const std::vector<std::vector<types::global_dof_index>> &indices,
- std::vector<FullMatrix<Number>> & blocks);
+ std::vector<FullMatrix<Number>> &blocks);
#ifndef DOXYGEN
typename SparseMatrixType,
typename SparsityPatternType>
std::vector<std::vector<std::pair<types::global_dof_index, Number>>>
- extract_remote_rows(const SparseMatrixType & system_matrix,
+ extract_remote_rows(const SparseMatrixType &system_matrix,
const SparsityPatternType &sparsity_pattern,
- const IndexSet & locally_active_dofs,
+ const IndexSet &locally_active_dofs,
const MPI_Comm comm)
{
std::vector<unsigned int> dummy(locally_active_dofs.n_elements());
typename SparseMatrixType2,
typename SparsityPatternType2>
void
- restrict_to_serial_sparse_matrix(const SparseMatrixType & system_matrix,
+ restrict_to_serial_sparse_matrix(const SparseMatrixType &system_matrix,
const SparsityPatternType &sparsity_pattern,
- const IndexSet & index_set_0,
- const IndexSet & index_set_1,
- SparseMatrixType2 & system_matrix_out,
+ const IndexSet &index_set_0,
+ const IndexSet &index_set_1,
+ SparseMatrixType2 &system_matrix_out,
SparsityPatternType2 &sparsity_pattern_out)
{
Assert(index_set_1.size() == 0 || index_set_0.size() == index_set_1.size(),
typename SparseMatrixType2,
typename SparsityPatternType2>
void
- restrict_to_serial_sparse_matrix(const SparseMatrixType & system_matrix,
+ restrict_to_serial_sparse_matrix(const SparseMatrixType &system_matrix,
const SparsityPatternType &sparsity_pattern,
- const IndexSet & requested_is,
- SparseMatrixType2 & system_matrix_out,
+ const IndexSet &requested_is,
+ SparseMatrixType2 &system_matrix_out,
SparsityPatternType2 &sparsity_pattern_out)
{
restrict_to_serial_sparse_matrix(system_matrix,
typename Number>
void
restrict_to_full_matrices(
- const SparseMatrixType & system_matrix,
- const SparsityPatternType & sparsity_pattern,
+ const SparseMatrixType &system_matrix,
+ const SparsityPatternType &sparsity_pattern,
const std::vector<std::vector<types::global_dof_index>> &indices,
- std::vector<FullMatrix<Number>> & blocks)
+ std::vector<FullMatrix<Number>> &blocks)
{
// 0) determine which rows are locally owned and which ones are remote
const auto local_size = internal::get_local_size(system_matrix);
continue;
const auto &local_dof_indices = indices[c];
- auto & cell_matrix = blocks[c];
+ auto &cell_matrix = blocks[c];
// allocate memory
const unsigned int dofs_per_cell = indices[c].size();
typename SparsityPatternType,
typename Number>
void
- restrict_to_cells(const SparseMatrixType & system_matrix,
- const SparsityPatternType & sparsity_pattern,
+ restrict_to_cells(const SparseMatrixType &system_matrix,
+ const SparsityPatternType &sparsity_pattern,
const DoFHandler<dim, spacedim> &dof_handler,
std::vector<FullMatrix<Number>> &blocks)
{
template <typename somenumber>
void
initialize(const SparseMatrix<somenumber> &matrix,
- const AdditionalData & parameters = AdditionalData());
+ const AdditionalData ¶meters = AdditionalData());
/**
* Apply the incomplete decomposition, i.e. do one forward-backward step
template <typename somenumber>
inline void
SparseMIC<number>::initialize(const SparseMatrix<somenumber> &matrix,
- const AdditionalData & data)
+ const AdditionalData &data)
{
Assert(matrix.m() == matrix.n(), ExcNotQuadratic());
Assert(data.strengthen_diagonal >= 0,
template <typename number>
template <typename somenumber>
void
-SparseMIC<number>::vmult(Vector<somenumber> & dst,
+SparseMIC<number>::vmult(Vector<somenumber> &dst,
const Vector<somenumber> &src) const
{
Assert(dst.size() == src.size(),
*/
void
initialize(const SparseMatrix<number> &M,
- const AdditionalData & additional_data);
+ const AdditionalData &additional_data);
/**
* Do the preconditioning. This function takes the residual in @p src and
*/
template <typename number2>
void
- apply_preconditioner(Vector<number2> & dst,
- const Vector<number2> & src,
+ apply_preconditioner(Vector<number2> &dst,
+ const Vector<number2> &src,
const std::vector<bool> *const dof_mask = nullptr) const;
/**
* Constructor. Pass all arguments except for @p n_blocks to the base class.
*/
SparseBlockVanka(const SparseMatrix<number> &M,
- const std::vector<bool> & selected,
+ const std::vector<bool> &selected,
const unsigned int n_blocks,
const BlockingStrategy blocking_strategy);
*/
void
compute_dof_masks(const SparseMatrix<number> &M,
- const std::vector<bool> & selected,
+ const std::vector<bool> &selected,
const BlockingStrategy blocking_strategy);
};
template <typename number>
SparseVanka<number>::SparseVanka(const SparseMatrix<number> &M,
- const std::vector<bool> & selected_dofs)
+ const std::vector<bool> &selected_dofs)
: matrix(&M, typeid(*this).name())
, selected(&selected_dofs)
, inverses(M.m(), nullptr)
template <typename number>
void
SparseVanka<number>::initialize(const SparseMatrix<number> &M,
- const AdditionalData & additional_data)
+ const AdditionalData &additional_data)
{
matrix = &M;
selected = &(additional_data.selected);
template <typename number>
template <typename number2>
void
-SparseVanka<number>::vmult(Vector<number2> & dst,
+SparseVanka<number>::vmult(Vector<number2> &dst,
const Vector<number2> &src) const
{
Assert(matrix != nullptr, ExcNotInitialized());
template <typename number2>
void
SparseVanka<number>::apply_preconditioner(
- Vector<number2> & dst,
- const Vector<number2> & src,
+ Vector<number2> &dst,
+ const Vector<number2> &src,
const std::vector<bool> *const dof_mask) const
{
Assert(dst.size() == src.size(),
template <typename number>
SparseBlockVanka<number>::SparseBlockVanka(
const SparseMatrix<number> &M,
- const std::vector<bool> & selected,
+ const std::vector<bool> &selected,
const unsigned int n_blocks,
const BlockingStrategy blocking_strategy)
: SparseVanka<number>(M, selected)
void
SparseBlockVanka<number>::compute_dof_masks(
const SparseMatrix<number> &M,
- const std::vector<bool> & selected,
+ const std::vector<bool> &selected,
const BlockingStrategy blocking_strategy)
{
Assert(n_blocks > 0, ExcInternalError());
template <typename number>
template <typename number2>
void
-SparseBlockVanka<number>::vmult(Vector<number2> & dst,
+SparseBlockVanka<number>::vmult(Vector<number2> &dst,
const Vector<number2> &src) const
{
dst = 0;
const bool indices_are_sorted = false);
virtual void
- add_row_entries(const size_type & row,
+ add_row_entries(const size_type &row,
const ArrayView<const size_type> &columns,
const bool indices_are_sorted = false) override;
typename std::iterator_traits<ForwardIterator>::value_type::const_iterator;
for (ForwardIterator i = begin; i != end; ++i, ++row)
{
- size_type * cols = &colnums[rowstart[row]] + (is_square ? 1 : 0);
+ size_type *cols = &colnums[rowstart[row]] + (is_square ? 1 : 0);
const inner_iterator end_of_row = i->end();
for (inner_iterator j = i->begin(); j != end_of_row; ++j)
{
* Optimized function for adding new entries to a given row.
*/
virtual void
- add_row_entries(const size_type & row,
+ add_row_entries(const size_type &row,
const ArrayView<const size_type> &columns,
const bool indices_are_sorted = false) = 0;
* done by calling @p GridTools::partition_triangulation.
*/
void
- partition(const SparsityPattern & sparsity_pattern,
+ partition(const SparsityPattern &sparsity_pattern,
const unsigned int n_partitions,
std::vector<unsigned int> &partition_indices,
const Partitioner partitioner = Partitioner::metis);
* number of active cells in the triangulation.
*/
void
- partition(const SparsityPattern & sparsity_pattern,
+ partition(const SparsityPattern &sparsity_pattern,
const std::vector<unsigned int> &cell_weights,
const unsigned int n_partitions,
- std::vector<unsigned int> & partition_indices,
+ std::vector<unsigned int> &partition_indices,
const Partitioner partitioner = Partitioner::metis);
/**
* coloring arising in shared-memory parallel assembly of matrices.
*/
unsigned int
- color_sparsity_pattern(const SparsityPattern & sparsity_pattern,
+ color_sparsity_pattern(const SparsityPattern &sparsity_pattern,
std::vector<unsigned int> &color_indices);
/**
*/
void
reorder_Cuthill_McKee(
- const DynamicSparsityPattern & sparsity,
- std::vector<DynamicSparsityPattern::size_type> & new_indices,
+ const DynamicSparsityPattern &sparsity,
+ std::vector<DynamicSparsityPattern::size_type> &new_indices,
const std::vector<DynamicSparsityPattern::size_type> &starting_indices =
std::vector<DynamicSparsityPattern::size_type>());
*/
void
reorder_hierarchical(
- const DynamicSparsityPattern & sparsity,
+ const DynamicSparsityPattern &sparsity,
std::vector<DynamicSparsityPattern::size_type> &new_indices);
#ifdef DEAL_II_WITH_MPI
*/
void
distribute_sparsity_pattern(DynamicSparsityPattern &dsp,
- const IndexSet & locally_owned_rows,
+ const IndexSet &locally_owned_rows,
const MPI_Comm mpi_comm,
- const IndexSet & locally_relevant_rows);
+ const IndexSet &locally_relevant_rows);
/**
* Communicate rows in a dynamic sparsity pattern over MPI, similar to the
*/
void
distribute_sparsity_pattern(
- DynamicSparsityPattern & dsp,
+ DynamicSparsityPattern &dsp,
const std::vector<DynamicSparsityPattern::size_type> &rows_per_cpu,
const MPI_Comm mpi_comm,
- const IndexSet & myrange);
+ const IndexSet &myrange);
/**
* Similar to the function above, but for BlockDynamicSparsityPattern
*/
void
distribute_sparsity_pattern(BlockDynamicSparsityPattern &dsp,
- const IndexSet & locally_owned_rows,
+ const IndexSet &locally_owned_rows,
const MPI_Comm mpi_comm,
const IndexSet &locally_relevant_rows);
distribute_sparsity_pattern(BlockDynamicSparsityPattern &dsp,
const std::vector<IndexSet> &owned_set_per_cpu,
const MPI_Comm mpi_comm,
- const IndexSet & myrange);
+ const IndexSet &myrange);
/**
* Gather rows in a dynamic sparsity pattern over MPI.
*/
void
gather_sparsity_pattern(DynamicSparsityPattern &dsp,
- const IndexSet & locally_owned_rows,
+ const IndexSet &locally_owned_rows,
const MPI_Comm mpi_comm,
- const IndexSet & locally_relevant_rows);
+ const IndexSet &locally_relevant_rows);
#endif
* internally to the needed size.
*/
void
- vmult(const ArrayView<Number> & dst,
+ vmult(const ArrayView<Number> &dst,
const ArrayView<const Number> &src,
- AlignedVector<Number> & tmp) const;
+ AlignedVector<Number> &tmp) const;
/**
* Implements a matrix-vector product with the underlying matrix as
* array bounds with respect to @p dst and @p src.
*/
void
- apply_inverse(const ArrayView<Number> & dst,
+ apply_inverse(const ArrayView<Number> &dst,
const ArrayView<const Number> &src) const;
/**
*/
void
apply_inverse(const unsigned int index,
- const ArrayView<Number> & dst_in,
+ const ArrayView<Number> &dst_in,
const ArrayView<const Number> &src_in) const;
/**
*/
template <typename Number>
void
- spectral_assembly(const Number * mass_matrix,
- const Number * derivative_matrix,
+ spectral_assembly(const Number *mass_matrix,
+ const Number *derivative_matrix,
const unsigned int n_rows,
const unsigned int n_cols,
- Number * eigenvalues,
- Number * eigenvectors)
+ Number *eigenvalues,
+ Number *eigenvectors)
{
Assert(n_rows == n_cols, ExcNotImplemented());
}
}
- const auto transpose_fill_nm = [&constrained_dofs](Number * out,
- const Number * in,
+ const auto transpose_fill_nm = [&constrained_dofs](Number *out,
+ const Number *in,
const unsigned int n,
const unsigned int m) {
for (unsigned int mm = 0, c = 0; mm < m; ++mm)
inline void
setup(const std::array<Table<2, Number>, dim> &mass_matrix,
const std::array<Table<2, Number>, dim> &derivative_matrix,
- std::array<Table<2, Number>, dim> & eigenvectors,
- std::array<AlignedVector<Number>, dim> & eigenvalues)
+ std::array<Table<2, Number>, dim> &eigenvectors,
+ std::array<AlignedVector<Number>, dim> &eigenvalues)
{
const unsigned int n_rows_1d = mass_matrix[0].n_cols();
(void)n_rows_1d;
const Number *mass_cbegin = mass_matrix_flat.data();
const Number *deriv_cbegin = deriv_matrix_flat.data();
- Number * eigenvec_begin = eigenvectors_flat.data();
- Number * eigenval_begin = eigenvalues_flat.data();
+ Number *eigenvec_begin = eigenvectors_flat.data();
+ Number *eigenval_begin = eigenvalues_flat.data();
for (unsigned int lane = 0; lane < macro_size; ++lane)
internal::TensorProductMatrixSymmetricSum::spectral_assembly<
Number>(mass_cbegin + nm * lane,
template <int n_rows_1d_templated, std::size_t dim, typename Number>
void
- vmult(Number * dst,
- const Number * src,
- AlignedVector<Number> & tmp,
+ vmult(Number *dst,
+ const Number *src,
+ AlignedVector<Number> &tmp,
const unsigned int n_rows_1d_non_templated,
const std::array<const Number *, dim> &mass_matrix,
const std::array<const Number *, dim> &derivative_matrix)
template <int n_rows_1d_templated, std::size_t dim, typename Number>
void
- apply_inverse(Number * dst,
- const Number * src,
+ apply_inverse(Number *dst,
+ const Number *src,
const unsigned int n_rows_1d_non_templated,
const std::array<const Number *, dim> &eigenvectors,
const std::array<const Number *, dim> &eigenvalues,
template <int n_rows_1d_templated, std::size_t dim, typename Number>
void
- select_vmult(Number * dst,
- const Number * src,
- AlignedVector<Number> & tmp,
+ select_vmult(Number *dst,
+ const Number *src,
+ AlignedVector<Number> &tmp,
const unsigned int n_rows_1d,
const std::array<const Number *, dim> &mass_matrix,
const std::array<const Number *, dim> &derivative_matrix);
template <int n_rows_1d_templated, std::size_t dim, typename Number>
void
- select_apply_inverse(Number * dst,
- const Number * src,
+ select_apply_inverse(Number *dst,
+ const Number *src,
const unsigned int n_rows_1d,
const std::array<const Number *, dim> &eigenvectors,
const std::array<const Number *, dim> &eigenvalues,
template <int dim, typename Number, int n_rows_1d>
inline void
TensorProductMatrixSymmetricSum<dim, Number, n_rows_1d>::vmult(
- const ArrayView<Number> & dst_view,
+ const ArrayView<Number> &dst_view,
const ArrayView<const Number> &src_view) const
{
std::lock_guard<std::mutex> lock(this->mutex);
template <int dim, typename Number, int n_rows_1d>
inline void
TensorProductMatrixSymmetricSum<dim, Number, n_rows_1d>::vmult(
- const ArrayView<Number> & dst_view,
+ const ArrayView<Number> &dst_view,
const ArrayView<const Number> &src_view,
- AlignedVector<Number> & tmp_array) const
+ AlignedVector<Number> &tmp_array) const
{
AssertDimension(dst_view.size(), this->m());
AssertDimension(src_view.size(), this->n());
- Number * dst = dst_view.begin();
+ Number *dst = dst_view.begin();
const Number *src = src_view.begin();
std::array<const Number *, dim> mass_matrix, derivative_matrix;
template <int dim, typename Number, int n_rows_1d>
inline void
TensorProductMatrixSymmetricSum<dim, Number, n_rows_1d>::apply_inverse(
- const ArrayView<Number> & dst_view,
+ const ArrayView<Number> &dst_view,
const ArrayView<const Number> &src_view) const
{
AssertDimension(dst_view.size(), this->n());
AssertDimension(src_view.size(), this->m());
- Number * dst = dst_view.begin();
+ Number *dst = dst_view.begin();
const Number *src = src_view.begin();
std::array<const Number *, dim> eigenvectors, eigenvalues;
void
TensorProductMatrixSymmetricSumCollection<dim, Number, n_rows_1d>::insert(
const unsigned int index,
- const T & Ms_in,
- const T & Ks_in)
+ const T &Ms_in,
+ const T &Ks_in)
{
const auto Ms =
internal::TensorProductMatrixSymmetricSum::convert<dim>(Ms_in);
void
TensorProductMatrixSymmetricSumCollection<dim, Number, n_rows_1d>::
apply_inverse(const unsigned int index,
- const ArrayView<Number> & dst_in,
+ const ArrayView<Number> &dst_in,
const ArrayView<const Number> &src_in) const
{
- Number * dst = dst_in.begin();
+ Number *dst = dst_in.begin();
const Number *src = src_in.begin();
if (this->eigenvalues.empty() == false)
else
{
std::array<const Number *, dim> eigenvectors;
- const Number * inverted_eigenvalues = nullptr;
+ const Number *inverted_eigenvalues = nullptr;
unsigned int n_rows_1d_non_templated = 0;
for (unsigned int d = 0; d < dim; ++d)
{
template <int n_rows_1d_templated, std::size_t dim, typename Number>
void
- select_vmult(Number * dst,
- const Number * src,
- AlignedVector<Number> & tmp,
+ select_vmult(Number *dst,
+ const Number *src,
+ AlignedVector<Number> &tmp,
const unsigned int n_rows_1d,
const std::array<const Number *, dim> &mass_matrix,
const std::array<const Number *, dim> &derivative_matrix)
template <int n_rows_1d_templated, std::size_t dim, typename Number>
void
- select_apply_inverse(Number * dst,
- const Number * src,
+ select_apply_inverse(Number *dst,
+ const Number *src,
const unsigned int n_rows_1d,
const std::array<const Number *, dim> &eigenvectors,
const std::array<const Number *, dim> &eigenvalues,
* Source and destination must not be the same vector.
*/
void
- vmult(Vector<number> & w,
+ vmult(Vector<number> &w,
const Vector<number> &v,
const bool adding = false) const;
* Source and destination must not be the same vector.
*/
void
- Tvmult(Vector<number> & w,
+ Tvmult(Vector<number> &w,
const Vector<number> &v,
const bool adding = false) const;
*/
template <class OutputStream>
void
- print(OutputStream & s,
+ print(OutputStream &s,
const unsigned int width = 5,
const unsigned int precision = 2) const;
/** @} */
template <typename number>
template <class OutputStream>
void
-TridiagonalMatrix<number>::print(OutputStream & s,
+TridiagonalMatrix<number>::print(OutputStream &s,
const unsigned int width,
const unsigned int) const
{
*/
template <typename BlockSparsityPatternType>
void
- reinit(const std::vector<IndexSet> & input_maps,
+ reinit(const std::vector<IndexSet> &input_maps,
const BlockSparsityPatternType &block_sparsity_pattern,
const MPI_Comm communicator = MPI_COMM_WORLD,
const bool exchange_data = false);
*/
void
reinit(
- const std::vector<IndexSet> & parallel_partitioning,
+ const std::vector<IndexSet> ¶llel_partitioning,
const ::dealii::BlockSparseMatrix<double> &dealii_block_sparse_matrix,
const MPI_Comm communicator = MPI_COMM_WORLD,
const double drop_tolerance = 1e-13);
* This function only applicable if the matrix only has one block row.
*/
TrilinosScalar
- residual(MPI::BlockVector & dst,
+ residual(MPI::BlockVector &dst,
const MPI::BlockVector &x,
const MPI::BlockVector &b) const;
* This function is only applicable if the matrix only has one block row.
*/
TrilinosScalar
- residual(MPI::BlockVector & dst,
- const MPI::Vector & x,
+ residual(MPI::BlockVector &dst,
+ const MPI::Vector &x,
const MPI::BlockVector &b) const;
/**
* This function is only applicable if the matrix only has one block column.
*/
TrilinosScalar
- residual(MPI::Vector & dst,
+ residual(MPI::Vector &dst,
const MPI::BlockVector &x,
- const MPI::Vector & b) const;
+ const MPI::Vector &b) const;
/**
* Compute the residual of an equation <i>Mx=b</i>, where the residual is
* This function is only applicable if the matrix only has one block.
*/
TrilinosScalar
- residual(MPI::Vector & dst,
+ residual(MPI::Vector &dst,
const MPI::Vector &x,
const MPI::Vector &b) const;
*/
template <typename VectorType1, typename VectorType2>
void
- vmult(VectorType1 & dst,
+ vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
const std::integral_constant<bool, true>,
*/
template <typename VectorType1, typename VectorType2>
void
- vmult(VectorType1 & dst,
+ vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
const std::integral_constant<bool, false>,
*/
template <typename VectorType1, typename VectorType2>
void
- vmult(VectorType1 & dst,
+ vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
const std::integral_constant<bool, true>,
*/
template <typename VectorType1, typename VectorType2>
void
- vmult(VectorType1 & dst,
+ vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
const std::integral_constant<bool, false>,
template <typename VectorType1, typename VectorType2>
inline void
- BlockSparseMatrix::vmult(VectorType1 & dst,
+ BlockSparseMatrix::vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
std::integral_constant<bool, true>,
template <typename VectorType1, typename VectorType2>
inline void
- BlockSparseMatrix::vmult(VectorType1 & dst,
+ BlockSparseMatrix::vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
std::integral_constant<bool, false>,
template <typename VectorType1, typename VectorType2>
inline void
- BlockSparseMatrix::vmult(VectorType1 & dst,
+ BlockSparseMatrix::vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
std::integral_constant<bool, true>,
template <typename VectorType1, typename VectorType2>
inline void
- BlockSparseMatrix::vmult(VectorType1 & dst,
+ BlockSparseMatrix::vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
std::integral_constant<bool, false>,
* Prints the vector to the output stream @p out.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const bool across = true) const;
* either the 32 or 64 bit function.
*/
inline TrilinosWrappers::types::int_type
- global_index(const Epetra_BlockMap & map,
+ global_index(const Epetra_BlockMap &map,
const dealii::types::global_dof_index i)
{
# ifdef DEAL_II_WITH_64BIT_INDICES
* either the 32 or 64 bit function.
*/
inline TrilinosWrappers::types::int_type
- global_row_index(const Epetra_CrsMatrix & matrix,
+ global_row_index(const Epetra_CrsMatrix &matrix,
const dealii::types::global_dof_index i)
{
# ifdef DEAL_II_WITH_64BIT_INDICES
* either the 32 or 64 bit function.
*/
inline TrilinosWrappers::types::int_type
- global_column_index(const Epetra_CrsMatrix & matrix,
+ global_column_index(const Epetra_CrsMatrix &matrix,
const dealii::types::global_dof_index i)
{
# ifdef DEAL_II_WITH_64BIT_INDICES
Domain,
TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload>
linear_operator(const TrilinosWrappers::SparseMatrix &operator_exemplar,
- const Matrix & matrix)
+ const Matrix &matrix)
{
using OperatorExemplar = TrilinosWrappers::SparseMatrix;
using Payload =
Range,
Domain,
TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload>
- & operator_exemplar,
+ &operator_exemplar,
const Matrix &matrix)
{
using Payload =
void
reinit(
const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
- & partitioners,
+ &partitioners,
const bool make_ghosted = true,
const bool vector_writable = false);
*/
void
import_nonlocal_data_for_fe(const TrilinosWrappers::BlockSparseMatrix &m,
- const BlockVector & v);
+ const BlockVector &v);
/**
* Return if this Vector contains ghost elements.
* Print to a stream.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const bool across = true) const;
public:
template <typename Matrix>
static void
- reinit_range_vector(const Matrix & matrix,
+ reinit_range_vector(const Matrix &matrix,
TrilinosWrappers::MPI::BlockVector &v,
bool omit_zeroing_entries)
{
template <typename Matrix>
static void
- reinit_domain_vector(const Matrix & matrix,
+ reinit_domain_vector(const Matrix &matrix,
TrilinosWrappers::MPI::BlockVector &v,
bool omit_zeroing_entries)
{
* of the ones provided in the Trilinos wrapper class.
*/
virtual void
- Tvmult(dealii::Vector<double> & dst,
+ Tvmult(dealii::Vector<double> &dst,
const dealii::Vector<double> &src) const;
/**
* the ones provided in the Trilinos wrapper class.
*/
virtual void
- vmult(dealii::LinearAlgebra::distributed::Vector<double> & dst,
+ vmult(dealii::LinearAlgebra::distributed::Vector<double> &dst,
const dealii::LinearAlgebra::distributed::Vector<double> &src) const;
/**
* instead of the ones provided in the Trilinos wrapper class.
*/
virtual void
- Tvmult(dealii::LinearAlgebra::distributed::Vector<double> & dst,
+ Tvmult(dealii::LinearAlgebra::distributed::Vector<double> &dst,
const dealii::LinearAlgebra::distributed::Vector<double> &src) const;
/**
* and additional flags (damping parameter, etc.) if there are any.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
};
* computations, etc.) if there are any.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
};
* computations etc.) if there are any.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
};
* and additional flags (damping parameter, etc.) if there are any.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
};
* computations, etc.) if there are any.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
};
* computations etc.) if there are any.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
};
* computed of, and additional flags if there are any.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
};
* preconditioner, and additional flags if there are any.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
};
* preconditioner, and additional flags if there are any.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
};
* preconditioner, and additional flags if there are any.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
};
* preconditioner, and additional flags if there are any.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
};
const unsigned int smoother_sweeps = 2,
const unsigned int smoother_overlap = 0,
const bool output_details = false,
- const char * smoother_type = "Chebyshev",
- const char * coarse_type = "Amesos-KLU");
+ const char *smoother_type = "Chebyshev",
+ const char *coarse_type = "Amesos-KLU");
/**
* Fill in a @p parameter_list that can be used to initialize the
*/
void
set_parameters(
- Teuchos::ParameterList & parameter_list,
+ Teuchos::ParameterList ¶meter_list,
std::unique_ptr<Epetra_MultiVector> &distributed_constant_modes,
- const Epetra_RowMatrix & matrix) const;
+ const Epetra_RowMatrix &matrix) const;
/**
* Fill in a parameter list that can be used to initialize the
*/
void
set_parameters(
- Teuchos::ParameterList & parameter_list,
+ Teuchos::ParameterList ¶meter_list,
std::unique_ptr<Epetra_MultiVector> &distributed_constant_modes,
- const SparseMatrix & matrix) const;
+ const SparseMatrix &matrix) const;
/**
* Configure the null space setting in the @p parameter_list for
*/
void
set_operator_null_space(
- Teuchos::ParameterList & parameter_list,
+ Teuchos::ParameterList ¶meter_list,
std::unique_ptr<Epetra_MultiVector> &distributed_constant_modes,
- const Epetra_RowMatrix & matrix) const;
+ const Epetra_RowMatrix &matrix) const;
/**
* Configure the null space setting in the @p parameter_list for
*/
void
set_operator_null_space(
- Teuchos::ParameterList & parameter_list,
+ Teuchos::ParameterList ¶meter_list,
std::unique_ptr<Epetra_MultiVector> &distributed_constant_modes,
- const SparseMatrix & matrix) const;
+ const SparseMatrix &matrix) const;
/**
* Determines whether the AMG preconditioner should be optimized for
* format specified in TrilinosWrappers::SparseMatrix.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
*/
void
initialize(const Epetra_RowMatrix &matrix,
- const AdditionalData & additional_data = AdditionalData());
+ const AdditionalData &additional_data = AdditionalData());
/**
* Let Trilinos compute a multilevel hierarchy for the solution of a
* solved.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const Teuchos::ParameterList &ml_parameters);
/**
* objects to the ML preconditioner.
*/
void
- initialize(const Epetra_RowMatrix & matrix,
+ initialize(const Epetra_RowMatrix &matrix,
const Teuchos::ParameterList &ml_parameters);
/**
const unsigned int smoother_sweeps = 2,
const unsigned int smoother_overlap = 0,
const bool output_details = false,
- const char * smoother_type = "Chebyshev",
- const char * coarse_type = "Amesos-KLU");
+ const char *smoother_type = "Chebyshev",
+ const char *coarse_type = "Amesos-KLU");
/**
* Determines whether the AMG preconditioner should be optimized for
* format specified in TrilinosWrappers::SparseMatrix.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
*/
void
initialize(const Epetra_CrsMatrix &matrix,
- const AdditionalData & additional_data = AdditionalData());
+ const AdditionalData &additional_data = AdditionalData());
/**
* Let Trilinos compute a multilevel hierarchy for the solution of a
* MueLu option.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
Teuchos::ParameterList &muelu_parameters);
/**
* wrapped in a LinearOperator without an exemplar materix.
*/
void
- initialize(const SparseMatrix & matrix,
+ initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data = AdditionalData());
/**
* provided in the Trilinos wrapper class, i.e., dst = src.
*/
void
- vmult(dealii::Vector<double> & dst,
+ vmult(dealii::Vector<double> &dst,
const dealii::Vector<double> &src) const override;
/**
* of the ones provided in the Trilinos wrapper class, i.e. dst = src.
*/
void
- Tvmult(dealii::Vector<double> & dst,
+ Tvmult(dealii::Vector<double> &dst,
const dealii::Vector<double> &src) const override;
/**
* the ones provided in the Trilinos wrapper class, i.e., dst = src.
*/
void
- vmult(LinearAlgebra::distributed::Vector<double> & dst,
+ vmult(LinearAlgebra::distributed::Vector<double> &dst,
const dealii::LinearAlgebra::distributed::Vector<double> &src)
const override;
* src.
*/
void
- Tvmult(LinearAlgebra::distributed::Vector<double> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<double> &dst,
const dealii::LinearAlgebra::distributed::Vector<double> &src)
const override;
};
// <code>const</code> in all deal.II calls) to non-constant value, as this
// is the way Trilinos wants to have them.
inline void
- PreconditionBase::vmult(dealii::Vector<double> & dst,
+ PreconditionBase::vmult(dealii::Vector<double> &dst,
const dealii::Vector<double> &src) const
{
AssertDimension(dst.size(),
inline void
- PreconditionBase::Tvmult(dealii::Vector<double> & dst,
+ PreconditionBase::Tvmult(dealii::Vector<double> &dst,
const dealii::Vector<double> &src) const
{
AssertDimension(dst.size(),
inline void
PreconditionBase::vmult(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
AssertDimension(dst.locally_owned_size(),
inline void
PreconditionBase::Tvmult(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
AssertDimension(dst.locally_owned_size(),
/**
* Constructor. Takes the solver control object and creates the solver.
*/
- SolverBase(SolverControl & cn,
+ SolverBase(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* specifies the solver name and sets the appropriate Krylov method.
*/
SolverBase(const enum SolverName solver_name,
- SolverControl & cn,
+ SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* one of the linear solvers and preconditioners of Trilinos is chosen.
*/
void
- solve(const SparseMatrix & A,
- MPI::Vector & x,
- const MPI::Vector & b,
+ solve(const SparseMatrix &A,
+ MPI::Vector &x,
+ const MPI::Vector &b,
const PreconditionBase &preconditioner);
/**
* Trilinos is chosen.
*/
void
- solve(const Epetra_Operator & A,
- MPI::Vector & x,
- const MPI::Vector & b,
+ solve(const Epetra_Operator &A,
+ MPI::Vector &x,
+ const MPI::Vector &b,
const PreconditionBase &preconditioner);
/**
*/
void
solve(const Epetra_Operator &A,
- MPI::Vector & x,
- const MPI::Vector & b,
+ MPI::Vector &x,
+ const MPI::Vector &b,
const Epetra_Operator &preconditioner);
/**
* of Trilinos is chosen.
*/
void
- solve(const Epetra_Operator & A,
- Epetra_MultiVector & x,
+ solve(const Epetra_Operator &A,
+ Epetra_MultiVector &x,
const Epetra_MultiVector &b,
- const PreconditionBase & preconditioner);
+ const PreconditionBase &preconditioner);
/**
* Solve the linear system <tt>Ax=b</tt> where both <tt>A</tt> and its
* of Trilinos is chosen.
*/
void
- solve(const Epetra_Operator & A,
- Epetra_MultiVector & x,
+ solve(const Epetra_Operator &A,
+ Epetra_MultiVector &x,
const Epetra_MultiVector &b,
- const Epetra_Operator & preconditioner);
+ const Epetra_Operator &preconditioner);
* will be thrown.
*/
void
- solve(const SparseMatrix & A,
- dealii::Vector<double> & x,
+ solve(const SparseMatrix &A,
+ dealii::Vector<double> &x,
const dealii::Vector<double> &b,
- const PreconditionBase & preconditioner);
+ const PreconditionBase &preconditioner);
/**
* Solve the linear system <tt>Ax=b</tt> where <tt>A</tt> is an operator.
* exception will be thrown.
*/
void
- solve(Epetra_Operator & A,
- dealii::Vector<double> & x,
+ solve(Epetra_Operator &A,
+ dealii::Vector<double> &x,
const dealii::Vector<double> &b,
- const PreconditionBase & preconditioner);
+ const PreconditionBase &preconditioner);
/**
* Solve the linear system <tt>Ax=b</tt> for deal.II's parallel
* solvers and preconditioners of Trilinos is chosen.
*/
void
- solve(const SparseMatrix & A,
- dealii::LinearAlgebra::distributed::Vector<double> & x,
+ solve(const SparseMatrix &A,
+ dealii::LinearAlgebra::distributed::Vector<double> &x,
const dealii::LinearAlgebra::distributed::Vector<double> &b,
const PreconditionBase &preconditioner);
* Trilinos is chosen.
*/
void
- solve(Epetra_Operator & A,
- dealii::LinearAlgebra::distributed::Vector<double> & x,
+ solve(Epetra_Operator &A,
+ dealii::LinearAlgebra::distributed::Vector<double> &x,
const dealii::LinearAlgebra::distributed::Vector<double> &b,
const PreconditionBase &preconditioner);
// provide a declaration for two explicit specializations
template <>
void
- SolverBase::set_preconditioner(AztecOO & solver,
+ SolverBase::set_preconditioner(AztecOO &solver,
const PreconditionBase &preconditioner);
template <>
void
- SolverBase::set_preconditioner(AztecOO & solver,
+ SolverBase::set_preconditioner(AztecOO &solver,
const Epetra_Operator &preconditioner);
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverGMRES(SolverControl & cn,
+ SolverGMRES(SolverControl &cn,
const AdditionalData &data = AdditionalData());
};
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverBicgstab(SolverControl & cn,
+ SolverBicgstab(SolverControl &cn,
const AdditionalData &data = AdditionalData());
};
* The last argument takes a structure with additional, solver dependent
* flags for tuning.
*/
- SolverTFQMR(SolverControl & cn,
+ SolverTFQMR(SolverControl &cn,
const AdditionalData &data = AdditionalData());
};
/**
* Constructor. Takes the solver control object and creates the solver.
*/
- SolverDirect(SolverControl & cn,
+ SolverDirect(SolverControl &cn,
const AdditionalData &data = AdditionalData());
/**
* refactorized during this call.
*/
void
- solve(dealii::LinearAlgebra::distributed::Vector<double> & x,
+ solve(dealii::LinearAlgebra::distributed::Vector<double> &x,
const dealii::LinearAlgebra::distributed::Vector<double> &b);
/**
* exception will be thrown.
*/
void
- solve(const SparseMatrix & A,
- dealii::Vector<double> & x,
+ solve(const SparseMatrix &A,
+ dealii::Vector<double> &x,
const dealii::Vector<double> &b);
/**
* there is no need for a preconditioner here.
*/
void
- solve(const SparseMatrix & A,
- dealii::LinearAlgebra::distributed::Vector<double> & x,
+ solve(const SparseMatrix &A,
+ dealii::LinearAlgebra::distributed::Vector<double> &x,
const dealii::LinearAlgebra::distributed::Vector<double> &b);
/**
/**
* Constructor.
*/
- SolverBelos(SolverControl & solver_control,
- const AdditionalData & additional_data,
+ SolverBelos(SolverControl &solver_control,
+ const AdditionalData &additional_data,
const Teuchos::RCP<Teuchos::ParameterList> &belos_parameters);
/**
*/
template <typename OperatorType, typename PreconditionerType>
void
- solve(const OperatorType & a,
- VectorType & x,
- const VectorType & b,
+ solve(const OperatorType &a,
+ VectorType &x,
+ const VectorType &b,
const PreconditionerType &p);
private:
- SolverControl & solver_control;
+ SolverControl &solver_control;
const AdditionalData additional_data;
const Teuchos::RCP<Teuchos::ParameterList> &belos_parameters;
};
*/
virtual void
MvTimesMatAddMv(const value_type alpha,
- const Belos::MultiVec<value_type> & A_,
+ const Belos::MultiVec<value_type> &A_,
const Teuchos::SerialDenseMatrix<int, value_type> &B,
const value_type beta)
{
*/
virtual void
MvTransMv(const value_type alpha,
- const Belos::MultiVec<value_type> & A_,
+ const Belos::MultiVec<value_type> &A_,
Teuchos::SerialDenseMatrix<int, value_type> &B) const
{
const auto &A = try_to_get_underlying_vector(A_);
*/
virtual void
MvDot(const Belos::MultiVec<value_type> &A_,
- std::vector<value_type> & b) const
+ std::vector<value_type> &b) const
{
const auto &A = try_to_get_underlying_vector(A_);
virtual void
MvNorm(
std::vector<typename Teuchos::ScalarTraits<value_type>::magnitudeType>
- & normvec,
+ &normvec,
Belos::NormType type = Belos::TwoNorm) const
{
AssertThrow(type == Belos::TwoNorm, ExcNotImplemented());
*/
virtual void
SetBlock(const Belos::MultiVec<value_type> &A,
- const std::vector<int> & index)
+ const std::vector<int> &index)
{
AssertThrow(false, ExcNotImplemented());
(void)A;
*/
virtual void
Apply(const Belos::MultiVec<value_type> &x,
- Belos::MultiVec<value_type> & y,
+ Belos::MultiVec<value_type> &y,
Belos::ETrans trans = Belos::NOTRANS) const
{
// TODO: check for Tvmult
template <typename VectorType>
SolverBelos<VectorType>::SolverBelos(
- SolverControl & solver_control,
- const AdditionalData & additional_data,
+ SolverControl &solver_control,
+ const AdditionalData &additional_data,
const Teuchos::RCP<Teuchos::ParameterList> &belos_parameters)
: solver_control(solver_control)
, additional_data(additional_data)
template <typename VectorType>
template <typename OperatorType, typename PreconditionerType>
void
- SolverBelos<VectorType>::solve(const OperatorType & A_dealii,
- VectorType & x_dealii,
- const VectorType & b_dealii,
+ SolverBelos<VectorType>::solve(const OperatorType &A_dealii,
+ VectorType &x_dealii,
+ const VectorType &b_dealii,
const PreconditionerType &P_dealii)
{
using value_type = typename VectorType::value_type;
/**
* Constructor.
*/
- AccessorBase(SparseMatrix * matrix,
+ AccessorBase(SparseMatrix *matrix,
const size_type row,
const size_type index);
reinit(const ::dealii::SparseMatrix<number> &dealii_sparse_matrix,
const double drop_tolerance = 1e-13,
const bool copy_values = true,
- const ::dealii::SparsityPattern * use_this_sparsity = nullptr);
+ const ::dealii::SparsityPattern *use_this_sparsity = nullptr);
/**
* This reinit function takes as input a Trilinos Epetra_CrsMatrix and
* vector products, since Trilinos reorganizes the matrix memory prior to
* use (in the compress() step).
*/
- SparseMatrix(const IndexSet & parallel_partitioning,
+ SparseMatrix(const IndexSet ¶llel_partitioning,
const MPI_Comm communicator = MPI_COMM_WORLD,
const unsigned int n_max_entries_per_row = 0);
* makes the creation process including the insertion of nonzero elements
* by the respective SparseMatrix::reinit call considerably faster.
*/
- SparseMatrix(const IndexSet & parallel_partitioning,
+ SparseMatrix(const IndexSet ¶llel_partitioning,
const MPI_Comm communicator,
const std::vector<unsigned int> &n_entries_per_row);
* in any case. The vector <tt>n_entries_per_row</tt> specifies the number
* of entries in each row of the newly generated matrix.
*/
- SparseMatrix(const IndexSet & row_parallel_partitioning,
- const IndexSet & col_parallel_partitioning,
+ SparseMatrix(const IndexSet &row_parallel_partitioning,
+ const IndexSet &col_parallel_partitioning,
const MPI_Comm communicator,
const std::vector<unsigned int> &n_entries_per_row);
*/
template <typename SparsityPatternType>
void
- reinit(const IndexSet & parallel_partitioning,
+ reinit(const IndexSet ¶llel_partitioning,
const SparsityPatternType &sparsity_pattern,
const MPI_Comm communicator = MPI_COMM_WORLD,
const bool exchange_data = false);
template <typename SparsityPatternType>
std::enable_if_t<
!std::is_same_v<SparsityPatternType, dealii::SparseMatrix<double>>>
- reinit(const IndexSet & row_parallel_partitioning,
- const IndexSet & col_parallel_partitioning,
+ reinit(const IndexSet &row_parallel_partitioning,
+ const IndexSet &col_parallel_partitioning,
const SparsityPatternType &sparsity_pattern,
const MPI_Comm communicator = MPI_COMM_WORLD,
const bool exchange_data = false);
*/
template <typename number>
void
- reinit(const IndexSet & parallel_partitioning,
+ reinit(const IndexSet ¶llel_partitioning,
const ::dealii::SparseMatrix<number> &dealii_sparse_matrix,
const MPI_Comm communicator = MPI_COMM_WORLD,
const double drop_tolerance = 1e-13,
const bool copy_values = true,
- const ::dealii::SparsityPattern * use_this_sparsity = nullptr);
+ const ::dealii::SparsityPattern *use_this_sparsity = nullptr);
/**
* This function is similar to the other initialization function with
*/
template <typename number>
void
- reinit(const IndexSet & row_parallel_partitioning,
- const IndexSet & col_parallel_partitioning,
+ reinit(const IndexSet &row_parallel_partitioning,
+ const IndexSet &col_parallel_partitioning,
const ::dealii::SparseMatrix<number> &dealii_sparse_matrix,
const MPI_Comm communicator = MPI_COMM_WORLD,
const double drop_tolerance = 1e-13,
const bool copy_values = true,
- const ::dealii::SparsityPattern * use_this_sparsity = nullptr);
+ const ::dealii::SparsityPattern *use_this_sparsity = nullptr);
/** @} */
/**
* @name Information on the matrix
* structure before inserting elements.
*/
void
- set(const std::vector<size_type> & indices,
+ set(const std::vector<size_type> &indices,
const FullMatrix<TrilinosScalar> &full_matrix,
const bool elide_zero_values = false);
* rows and columns, respectively.
*/
void
- set(const std::vector<size_type> & row_indices,
- const std::vector<size_type> & col_indices,
+ set(const std::vector<size_type> &row_indices,
+ const std::vector<size_type> &col_indices,
const FullMatrix<TrilinosScalar> &full_matrix,
const bool elide_zero_values = false);
*/
void
set(const size_type row,
- const std::vector<size_type> & col_indices,
+ const std::vector<size_type> &col_indices,
const std::vector<TrilinosScalar> &values,
const bool elide_zero_values = false);
set(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const Number * values,
+ const Number *values,
const bool elide_zero_values = false);
/**
* <tt>true</tt>, i.e., zero values won't be added into the matrix.
*/
void
- add(const std::vector<size_type> & indices,
+ add(const std::vector<size_type> &indices,
const FullMatrix<TrilinosScalar> &full_matrix,
const bool elide_zero_values = true);
* rows and columns, respectively.
*/
void
- add(const std::vector<size_type> & row_indices,
- const std::vector<size_type> & col_indices,
+ add(const std::vector<size_type> &row_indices,
+ const std::vector<size_type> &col_indices,
const FullMatrix<TrilinosScalar> &full_matrix,
const bool elide_zero_values = true);
*/
void
add(const size_type row,
- const std::vector<size_type> & col_indices,
+ const std::vector<size_type> &col_indices,
const std::vector<TrilinosScalar> &values,
const bool elide_zero_values = true);
void
add(const size_type row,
const size_type n_cols,
- const size_type * col_indices,
+ const size_type *col_indices,
const TrilinosScalar *values,
const bool elide_zero_values = true,
const bool col_indices_are_sorted = false);
* distributed. Otherwise, an exception will be thrown.
*/
TrilinosScalar
- residual(MPI::Vector & dst,
+ residual(MPI::Vector &dst,
const MPI::Vector &x,
const MPI::Vector &b) const;
* think twice before you use this function.
*/
void
- mmult(SparseMatrix & C,
+ mmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V = MPI::Vector()) const;
+ const MPI::Vector &V = MPI::Vector()) const;
/**
* think twice before you use this function.
*/
void
- Tmmult(SparseMatrix & C,
+ Tmmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V = MPI::Vector()) const;
+ const MPI::Vector &V = MPI::Vector()) const;
/** @} */
/**
namespace internal
{
inline void
- check_vector_map_equality(const Epetra_CrsMatrix & mtrx,
+ check_vector_map_equality(const Epetra_CrsMatrix &mtrx,
const Epetra_MultiVector &src,
const Epetra_MultiVector &dst,
const bool transpose)
}
inline void
- check_vector_map_equality(const Epetra_Operator & op,
+ check_vector_map_equality(const Epetra_Operator &op,
const Epetra_MultiVector &src,
const Epetra_MultiVector &dst,
const bool transpose)
/**
* Constructor for a sparse matrix based on an exemplary payload
*/
- TrilinosPayload(const TrilinosPayload & payload_exemplar,
+ TrilinosPayload(const TrilinosPayload &payload_exemplar,
const TrilinosWrappers::SparseMatrix &matrix);
/**
* Constructor for a preconditioner based on an exemplary matrix
*/
TrilinosPayload(
- const TrilinosWrappers::SparseMatrix & matrix_exemplar,
+ const TrilinosWrappers::SparseMatrix &matrix_exemplar,
const TrilinosWrappers::PreconditionBase &preconditioner);
/**
* Constructor for a preconditioner based on an exemplary payload
*/
TrilinosPayload(
- const TrilinosPayload & payload_exemplar,
+ const TrilinosPayload &payload_exemplar,
const TrilinosWrappers::PreconditionBase &preconditioner);
/**
* have such a facility.
*/
template <typename EpetraOpType>
- TrilinosPayload(EpetraOpType & op,
+ TrilinosPayload(EpetraOpType &op,
const bool supports_inverse_operations,
const bool use_transpose,
const MPI_Comm mpi_communicator,
}
- inline Accessor<true>::Accessor(MatrixType * matrix,
+ inline Accessor<true>::Accessor(MatrixType *matrix,
const size_type row,
const size_type index)
: AccessorBase(const_cast<SparseMatrix *>(matrix), row, index)
}
- inline Accessor<false>::Accessor(MatrixType * matrix,
+ inline Accessor<false>::Accessor(MatrixType *matrix,
const size_type row,
const size_type index)
: AccessorBase(matrix, row, index)
template <bool Constness>
- inline Iterator<Constness>::Iterator(MatrixType * matrix,
+ inline Iterator<Constness>::Iterator(MatrixType *matrix,
const size_type row,
const size_type index)
: accessor(matrix, row, index)
void
SparseMatrix::set<TrilinosScalar>(const size_type row,
const size_type n_cols,
- const size_type * col_indices,
+ const size_type *col_indices,
const TrilinosScalar *values,
const bool elide_zero_values);
SparseMatrix::set(const size_type row,
const size_type n_cols,
const size_type *col_indices,
- const Number * values,
+ const Number *values,
const bool elide_zero_values)
{
std::vector<TrilinosScalar> trilinos_values(n_cols);
inline void
- SparseMatrix::set(const std::vector<size_type> & indices,
+ SparseMatrix::set(const std::vector<size_type> &indices,
const FullMatrix<TrilinosScalar> &values,
const bool elide_zero_values)
{
template <typename SparsityPatternType>
inline void
- SparseMatrix::reinit(const IndexSet & parallel_partitioning,
+ SparseMatrix::reinit(const IndexSet ¶llel_partitioning,
const SparsityPatternType &sparsity_pattern,
const MPI_Comm communicator,
const bool exchange_data)
const MPI_Comm communicator,
const double drop_tolerance,
const bool copy_values,
- const ::dealii::SparsityPattern * use_this_sparsity)
+ const ::dealii::SparsityPattern *use_this_sparsity)
{
Epetra_Map map =
parallel_partitioning.make_trilinos_map(communicator, false);
{
template <typename EpetraOpType>
TrilinosPayload::TrilinosPayload(
- EpetraOpType & op,
+ EpetraOpType &op,
const bool supports_inverse_operations,
const bool use_transpose,
const MPI_Comm mpi_communicator,
std::is_base_of_v<TrilinosWrappers::PreconditionBase, Preconditioner>,
TrilinosPayload>
TrilinosPayload::inverse_payload(
- Solver & solver,
+ Solver &solver,
const Preconditioner &preconditioner) const
{
const auto &payload = *this;
// Capture by copy so the payloads are always valid
return_op.inv_vmult = [payload, &solver, &preconditioner](
- TrilinosPayload::Domain & tril_dst,
+ TrilinosPayload::Domain &tril_dst,
const TrilinosPayload::Range &tril_src) {
// Duplicated from TrilinosWrappers::PreconditionBase::vmult
// as well as from TrilinosWrappers::SparseMatrix::Tvmult
};
return_op.inv_Tvmult = [payload, &solver, &preconditioner](
- TrilinosPayload::Range & tril_dst,
+ TrilinosPayload::Range &tril_dst,
const TrilinosPayload::Domain &tril_src) {
// Duplicated from TrilinosWrappers::PreconditionBase::vmult
// as well as from TrilinosWrappers::SparseMatrix::Tvmult
void
SparseMatrix::set<TrilinosScalar>(const size_type row,
const size_type n_cols,
- const size_type * col_indices,
+ const size_type *col_indices,
const TrilinosScalar *values,
const bool elide_zero_values);
# endif // DOXYGEN
* knowing the indices of nonzero entries, which the sparsity pattern is
* designed to describe.
*/
- SparsityPattern(const IndexSet & parallel_partitioning,
+ SparsityPattern(const IndexSet ¶llel_partitioning,
const MPI_Comm communicator,
const std::vector<size_type> &n_entries_per_row);
* the same processor. The vector <tt>n_entries_per_row</tt> specifies the
* number of entries in each row of the newly generated matrix.
*/
- SparsityPattern(const IndexSet & row_parallel_partitioning,
- const IndexSet & col_parallel_partitioning,
+ SparsityPattern(const IndexSet &row_parallel_partitioning,
+ const IndexSet &col_parallel_partitioning,
const MPI_Comm communicator,
const std::vector<size_type> &n_entries_per_row);
* describe.
*/
void
- reinit(const IndexSet & parallel_partitioning,
+ reinit(const IndexSet ¶llel_partitioning,
const MPI_Comm communicator,
const std::vector<size_type> &n_entries_per_row);
* specifying the number of entries in each row of the sparsity pattern.
*/
void
- reinit(const IndexSet & row_parallel_partitioning,
- const IndexSet & col_parallel_partitioning,
+ reinit(const IndexSet &row_parallel_partitioning,
+ const IndexSet &col_parallel_partitioning,
const MPI_Comm communicator,
const std::vector<size_type> &n_entries_per_row);
*/
template <typename SparsityPatternType>
void
- reinit(const IndexSet & row_parallel_partitioning,
- const IndexSet & col_parallel_partitioning,
+ reinit(const IndexSet &row_parallel_partitioning,
+ const IndexSet &col_parallel_partitioning,
const SparsityPatternType &nontrilinos_sparsity_pattern,
const MPI_Comm communicator = MPI_COMM_WORLD,
const bool exchange_data = false);
*/
template <typename SparsityPatternType>
void
- reinit(const IndexSet & parallel_partitioning,
+ reinit(const IndexSet ¶llel_partitioning,
const SparsityPatternType &nontrilinos_sparsity_pattern,
const MPI_Comm communicator = MPI_COMM_WORLD,
const bool exchange_data = false);
const bool indices_are_sorted = false);
virtual void
- add_row_entries(const size_type & row,
+ add_row_entries(const size_type &row,
const ArrayView<const size_type> &columns,
const bool indices_are_sorted = false) override;
* Prints the vector to the output stream @p out.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const bool across = true) const;
void
Vector<Number>::extract_subvector_to(
const ArrayView<const types::global_dof_index> &indices,
- ArrayView<Number> & elements) const
+ ArrayView<Number> &elements) const
{
AssertDimension(indices.size(), elements.size());
const auto &vector = trilinos_vector();
{
// get a representation of the vector and
// loop over all the elements
- Number * start_ptr = vector->getDataNonConst().get();
+ Number *start_ptr = vector->getDataNonConst().get();
const Number *ptr = start_ptr,
*eptr = start_ptr + vector->getLocalLength();
unsigned int flag = 0;
template <typename Number>
void
- Vector<Number>::print(std::ostream & out,
+ Vector<Number>::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool across) const
* @ref GlossGhostedVector "vectors with ghost elements"
*/
Vector(const IndexSet ¶llel_partitioning,
- const Vector & v,
+ const Vector &v,
const MPI_Comm communicator = MPI_COMM_WORLD);
/**
* @ref GlossGhostedVector "vectors with ghost elements"
*/
template <typename Number>
- Vector(const IndexSet & parallel_partitioning,
+ Vector(const IndexSet ¶llel_partitioning,
const dealii::Vector<Number> &v,
const MPI_Comm communicator = MPI_COMM_WORLD);
void
import_nonlocal_data_for_fe(
const dealii::TrilinosWrappers::SparseMatrix &matrix,
- const Vector & vector);
+ const Vector &vector);
/**
* Imports all the elements present in the vector's IndexSet from the
*/
void
extract_subvector_to(const std::vector<size_type> &indices,
- std::vector<TrilinosScalar> & values) const;
+ std::vector<TrilinosScalar> &values) const;
/**
* Extract a range of elements all at once.
* the corresponding values in the second.
*/
void
- set(const std::vector<size_type> & indices,
+ set(const std::vector<size_type> &indices,
const std::vector<TrilinosScalar> &values);
/**
* function takes a deal.II vector of values.
*/
void
- set(const std::vector<size_type> & indices,
+ set(const std::vector<size_type> &indices,
const ::dealii::Vector<TrilinosScalar> &values);
/**
*/
void
set(const size_type n_elements,
- const size_type * indices,
+ const size_type *indices,
const TrilinosScalar *values);
/**
* stored in @p values to the vector components specified by @p indices.
*/
void
- add(const std::vector<size_type> & indices,
+ add(const std::vector<size_type> &indices,
const std::vector<TrilinosScalar> &values);
/**
* function takes a deal.II vector of values.
*/
void
- add(const std::vector<size_type> & indices,
+ add(const std::vector<size_type> &indices,
const ::dealii::Vector<TrilinosScalar> &values);
/**
*/
void
add(const size_type n_elements,
- const size_type * indices,
+ const size_type *indices,
const TrilinosScalar *values);
/**
*/
void
add(const TrilinosScalar a,
- const Vector & V,
+ const Vector &V,
const TrilinosScalar b,
- const Vector & W);
+ const Vector &W);
/**
* Scaling and simple vector addition, i.e. <tt>*this = s*(*this) +
* separate line each.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const bool across = true) const;
namespace internal
{
- inline VectorReference::VectorReference(MPI::Vector & vector,
+ inline VectorReference::VectorReference(MPI::Vector &vector,
const size_type index)
: vector(vector)
, index(index)
inline void
Vector::extract_subvector_to(const std::vector<size_type> &indices,
- std::vector<TrilinosScalar> & values) const
+ std::vector<TrilinosScalar> &values) const
{
for (size_type i = 0; i < indices.size(); ++i)
values[i] = operator()(indices[i]);
inline void
- Vector::set(const std::vector<size_type> & indices,
+ Vector::set(const std::vector<size_type> &indices,
const std::vector<TrilinosScalar> &values)
{
// if we have ghost values, do not allow
inline void
- Vector::set(const std::vector<size_type> & indices,
+ Vector::set(const std::vector<size_type> &indices,
const ::dealii::Vector<TrilinosScalar> &values)
{
// if we have ghost values, do not allow
inline void
Vector::set(const size_type n_elements,
- const size_type * indices,
+ const size_type *indices,
const TrilinosScalar *values)
{
// if we have ghost values, do not allow
inline void
- Vector::add(const std::vector<size_type> & indices,
+ Vector::add(const std::vector<size_type> &indices,
const std::vector<TrilinosScalar> &values)
{
// if we have ghost values, do not allow
inline void
- Vector::add(const std::vector<size_type> & indices,
+ Vector::add(const std::vector<size_type> &indices,
const ::dealii::Vector<TrilinosScalar> &values)
{
// if we have ghost values, do not allow
inline void
Vector::add(const size_type n_elements,
- const size_type * indices,
+ const size_type *indices,
const TrilinosScalar *values)
{
// if we have ghost values, do not allow
inline TrilinosScalar
Vector::add_and_dot(const TrilinosScalar a,
- const Vector & V,
- const Vector & W)
+ const Vector &V,
+ const Vector &W)
{
this->add(a, V);
return *this * W;
inline void
Vector::add(const TrilinosScalar a,
- const Vector & v,
+ const Vector &v,
const TrilinosScalar b,
- const Vector & w)
+ const Vector &w)
{
// if we have ghost values, do not allow
// writing to this vector at all.
inline void
Vector::sadd(const TrilinosScalar s,
const TrilinosScalar a,
- const Vector & v)
+ const Vector &v)
{
// if we have ghost values, do not allow
// writing to this vector at all.
template <typename number>
- Vector::Vector(const IndexSet & parallel_partitioner,
+ Vector::Vector(const IndexSet ¶llel_partitioner,
const dealii::Vector<number> &v,
const MPI_Comm communicator)
{
public:
template <typename Matrix>
static void
- reinit_range_vector(const Matrix & matrix,
+ reinit_range_vector(const Matrix &matrix,
TrilinosWrappers::MPI::Vector &v,
bool omit_zeroing_entries)
{
template <typename Matrix>
static void
- reinit_domain_vector(const Matrix & matrix,
+ reinit_domain_vector(const Matrix &matrix,
TrilinosWrappers::MPI::Vector &v,
bool omit_zeroing_entries)
{
*/
template <typename OperatorType, typename VectorType>
double
- lanczos_largest_eigenvalue(const OperatorType & H,
- const VectorType & v0,
+ lanczos_largest_eigenvalue(const OperatorType &H,
+ const VectorType &v0,
const unsigned int k,
VectorMemory<VectorType> &vector_memory,
- std::vector<double> * eigenvalues = nullptr);
+ std::vector<double> *eigenvalues = nullptr);
/**
* Apply Chebyshev polynomial of the operator @p H to @p x. For a
*/
template <typename OperatorType, typename VectorType>
void
- chebyshev_filter(VectorType & x,
- const OperatorType & H,
+ chebyshev_filter(VectorType &x,
+ const OperatorType &H,
const unsigned int n,
const std::pair<double, double> unwanted_spectrum,
const double tau,
- VectorMemory<VectorType> & vector_memory);
+ VectorMemory<VectorType> &vector_memory);
} // namespace LinearAlgebra
void
call_stev(const char jobz,
const types::blas_int n,
- Number * d,
- Number * e,
- Number * z,
+ Number *d,
+ Number *e,
+ Number *z,
const types::blas_int ldz,
- Number * work,
- types::blas_int * info);
+ Number *work,
+ types::blas_int *info);
} // namespace UtilitiesImplementation
} // namespace internal
template <typename OperatorType, typename VectorType>
double
- lanczos_largest_eigenvalue(const OperatorType & H,
- const VectorType & v0_,
+ lanczos_largest_eigenvalue(const OperatorType &H,
+ const VectorType &v0_,
const unsigned int k,
VectorMemory<VectorType> &vector_memory,
- std::vector<double> * eigenvalues)
+ std::vector<double> *eigenvalues)
{
// Do k-step Lanczos:
template <typename OperatorType, typename VectorType>
void
- chebyshev_filter(VectorType & x,
- const OperatorType & op,
+ chebyshev_filter(VectorType &x,
+ const OperatorType &op,
const unsigned int degree,
const std::pair<double, double> unwanted_spectrum,
const double a_L,
- VectorMemory<VectorType> & vector_memory)
+ VectorMemory<VectorType> &vector_memory)
{
const double a = unwanted_spectrum.first;
const double b = unwanted_spectrum.second;
template <typename OtherNumber>
void
extract_subvector_to(const std::vector<size_type> &indices,
- std::vector<OtherNumber> & values) const;
+ std::vector<OtherNumber> &values) const;
/**
* Extract a range of elements all at once.
*/
template <typename OtherNumber>
void
- add(const std::vector<size_type> & indices,
+ add(const std::vector<size_type> &indices,
const std::vector<OtherNumber> &values);
/**
template <typename OtherNumber>
void
add(const size_type n_elements,
- const size_type * indices,
+ const size_type *indices,
const OtherNumber *values);
/**
* while if @p false then the elements are printed on a separate line each.
*/
void
- print(std::ostream & out,
+ print(std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const bool across = true) const;
template <typename OtherNumber>
inline void
Vector<Number>::extract_subvector_to(const std::vector<size_type> &indices,
- std::vector<OtherNumber> & values) const
+ std::vector<OtherNumber> &values) const
{
for (size_type i = 0; i < indices.size(); ++i)
values[i] = operator()(indices[i]);
template <typename Number>
template <typename OtherNumber>
inline void
-Vector<Number>::add(const std::vector<size_type> & indices,
+Vector<Number>::add(const std::vector<size_type> &indices,
const std::vector<OtherNumber> &values)
{
Assert(indices.size() == values.size(),
template <typename OtherNumber>
inline void
Vector<Number>::add(const std::vector<size_type> &indices,
- const Vector<OtherNumber> & values)
+ const Vector<OtherNumber> &values)
{
Assert(indices.size() == values.size(),
ExcDimensionMismatch(indices.size(), values.size()));
template <typename OtherNumber>
inline void
Vector<Number>::add(const size_type n_indices,
- const size_type * indices,
+ const size_type *indices,
const OtherNumber *values)
{
for (size_type i = 0; i < n_indices; ++i)
template <typename Number>
-inline void Vector<Number>::compress(VectorOperation::values) const
+inline void
+Vector<Number>::compress(VectorOperation::values) const
{}
const size_type i,
const size_type k)
{
- auto & V = *this;
+ auto &V = *this;
const Number t = V(i);
V(i) = csr[0] * V(i) + csr[1] * V(k);
V(k) = -csr[1] * t + csr[0] * V(k);
template <typename Number>
void
copy_petsc_vector(const PETScWrappers::VectorBase &v,
- ::dealii::Vector<Number> & out)
+ ::dealii::Vector<Number> &out)
{
if (v.size() == 0)
{
void
Vector<Number>::extract_subvector_to(
const ArrayView<const types::global_dof_index> &indices,
- ArrayView<Number> & elements) const
+ ArrayView<Number> &elements) const
{
AssertDimension(indices.size(), elements.size());
for (unsigned int i = 0; i < indices.size(); ++i)
template <typename Number>
void
-Vector<Number>::print(std::ostream & out,
+Vector<Number>::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool across) const
static void
add(const typename VectorType::value_type value,
const types::global_dof_index i,
- VectorType & V);
+ VectorType &V);
static void
set(typename VectorType::value_type value,
const types::global_dof_index i,
- VectorType & V);
+ VectorType &V);
static typename VectorType::value_type
get(const VectorType &V, const types::global_dof_index i);
inline void
ElementAccess<VectorType>::add(const typename VectorType::value_type value,
const types::global_dof_index i,
- VectorType & V)
+ VectorType &V)
{
V(i) += value;
}
inline void
ElementAccess<VectorType>::set(const typename VectorType::value_type value,
const types::global_dof_index i,
- VectorType & V)
+ VectorType &V)
{
V(i) = value;
}
template <typename VectorType>
inline typename VectorType::value_type
- ElementAccess<VectorType>::get(const VectorType & V,
+ ElementAccess<VectorType>::get(const VectorType &V,
const types::global_dof_index i)
{
return V(i);
static void
add(const typename VectorType::value_type value,
const types::global_dof_index i,
- VectorType & V);
+ VectorType &V);
static void
set(typename VectorType::value_type value,
const types::global_dof_index i,
- VectorType & V);
+ VectorType &V);
static typename VectorType::value_type
get(const VectorType &V, const types::global_dof_index i);
// Extract local indices in the vector.
# if DEAL_II_TRILINOS_VERSION_GTE(13, 2, 0)
const Tpetra::Vector<NumberType, int, types::signed_global_dof_index>
- & vector = V.trilinos_vector();
+ &vector = V.trilinos_vector();
auto vector_2d =
vector.template getLocalView<Kokkos::HostSpace>(Tpetra::Access::ReadOnly);
# else
void
copy(const std::complex<T> *begin,
const std::complex<T> *end,
- std::complex<U> * dest)
+ std::complex<U> *dest)
{
std::copy(begin, end, dest);
}
template <typename Functor>
struct TBBForFunctor
{
- TBBForFunctor(Functor & functor,
+ TBBForFunctor(Functor &functor,
const size_type start,
const size_type end)
: functor(functor)
functor(r_begin, r_end);
}
- Functor & functor;
+ Functor &functor;
const size_type start;
const size_type end;
unsigned int n_chunks;
template <typename Functor>
void
parallel_for(
- Functor & functor,
+ Functor &functor,
const size_type start,
const size_type end,
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
template <typename Number>
struct Vectorization_sadd_xav
{
- Vectorization_sadd_xav(Number * val,
+ Vectorization_sadd_xav(Number *val,
const Number *const v_val,
const Number a,
const Number x)
template <typename Number>
struct Vectorization_sadd_xavbw
{
- Vectorization_sadd_xavbw(Number * val,
+ Vectorization_sadd_xavbw(Number *val,
const Number *v_val,
const Number *w_val,
Number x,
template <typename Number>
struct Vectorization_equ_aubvcw
{
- Vectorization_equ_aubvcw(Number * val,
+ Vectorization_equ_aubvcw(Number *val,
const Number *u_val,
const Number *v_val,
const Number *w_val,
return std::pow(std::abs(x), p);
}
- const Number * X;
+ const Number *X;
const RealType p;
};
accumulate_recursive(const Operation &op,
const size_type first,
const size_type last,
- ResultType & result)
+ ResultType &result)
{
if (first == last)
{
do_accumulate(const Operation op,
const size_type vec_size,
const size_type start_index,
- ResultType * outer_results,
+ ResultType *outer_results,
std::integral_constant<bool, false>)
{
// Create local copy to indicate no aliasing to the compiler
do_accumulate(const Operation op,
const size_type vec_size,
const size_type start_index,
- Number * outer_results,
+ Number *outer_results,
std::integral_constant<bool, true>)
{
// Create local copy to indicate no aliasing to the compiler
const Operation &op,
const size_type start,
const size_type end,
- ResultType & result,
+ ResultType &result,
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
&partitioner)
{
{
static void
copy(const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const ::dealii::MemorySpace::
MemorySpaceData<Number2, ::dealii::MemorySpace::Host> &v_data,
static void
set(const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const Number s,
::dealii::MemorySpace::MemorySpaceData<Number,
static void
add_vector(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const ::dealii::MemorySpace::
MemorySpaceData<Number, ::dealii::MemorySpace::Host> &v_data,
static void
subtract_vector(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const ::dealii::MemorySpace::
MemorySpaceData<Number, ::dealii::MemorySpace::Host> &v_data,
static void
add_factor(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
Number a,
::dealii::MemorySpace::MemorySpaceData<Number,
static void
add_av(const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const Number a,
const ::dealii::MemorySpace::
static void
add_avpbw(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const Number a,
const Number b,
static void
sadd_xv(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const Number x,
const ::dealii::MemorySpace::
static void
sadd_xav(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const Number x,
const Number a,
static void
sadd_xavbw(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const Number x,
const Number a,
static void
multiply_factor(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const Number factor,
::dealii::MemorySpace::MemorySpaceData<Number,
static void
scale(const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const ::dealii::MemorySpace::
MemorySpaceData<Number, ::dealii::MemorySpace::Host> &v_data,
static void
equ_au(const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const Number a,
const ::dealii::MemorySpace::
static void
equ_aubv(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const Number a,
const Number b,
static Number
dot(const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const ::dealii::MemorySpace::
MemorySpaceData<Number2, ::dealii::MemorySpace::Host> &v_data,
template <typename real_type>
static void
norm_2(const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
- real_type & sum,
+ real_type &sum,
::dealii::MemorySpace::MemorySpaceData<Number,
::dealii::MemorySpace::Host>
&data)
static Number
mean_value(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const ::dealii::MemorySpace::
MemorySpaceData<Number, ::dealii::MemorySpace::Host> &data)
template <typename real_type>
static void
norm_1(const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
- real_type & sum,
+ real_type &sum,
::dealii::MemorySpace::MemorySpaceData<Number,
::dealii::MemorySpace::Host>
&data)
template <typename real_type>
static void
norm_p(const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
- real_type & sum,
+ real_type &sum,
const real_type p,
::dealii::MemorySpace::MemorySpaceData<Number,
::dealii::MemorySpace::Host>
static Number
add_and_dot(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
const Number a,
const ::dealii::MemorySpace::
static void
import_elements(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
VectorOperation::values operation,
const ::dealii::MemorySpace::MemorySpaceData<Number, MemorySpace2>
template <typename real_type>
static void
norm_2(const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
- real_type & sum,
+ real_type &sum,
::dealii::MemorySpace::
MemorySpaceData<Number, ::dealii::MemorySpace::Default> &data)
{
norm_1(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner> &,
const size_type size,
- real_type & sum,
+ real_type &sum,
::dealii::MemorySpace::MemorySpaceData<Number,
::dealii::MemorySpace::Default>
&data)
norm_p(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner> &,
const size_type size,
- real_type & sum,
+ real_type &sum,
real_type exp,
::dealii::MemorySpace::MemorySpaceData<Number,
::dealii::MemorySpace::Default>
static void
import_elements(
const std::shared_ptr<::dealii::parallel::internal::TBBPartitioner>
- & thread_loop_partitioner,
+ &thread_loop_partitioner,
const size_type size,
VectorOperation::values operation,
const ::dealii::MemorySpace::MemorySpaceData<Number, MemorySpace2>
const unsigned int mg_level,
const TriaIterator<DoFCellAccessor<dim, dim, false>> &cell,
const dealii::AffineConstraints<typename Number::value_type>
- & constraints,
+ &constraints,
const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
/**
void
read_dof_indices(
const unsigned int cell_no,
- const std::vector<types::global_dof_index> & dof_indices,
+ const std::vector<types::global_dof_index> &dof_indices,
const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
void
template <typename T, typename VectorType>
void
- read_write_operation(const T & operation,
- VectorType & global_vector,
- Number * local_vector,
+ read_write_operation(const T &operation,
+ VectorType &global_vector,
+ Number *local_vector,
const unsigned int first_cell,
const unsigned int n_cells,
const unsigned int n_dofs_per_cell,
ConstraintInfo<dim, Number>::read_dof_indices(
const unsigned int cell_no,
const unsigned int mg_level,
- const TriaIterator<DoFCellAccessor<dim, dim, false>> & cell,
+ const TriaIterator<DoFCellAccessor<dim, dim, false>> &cell,
const dealii::AffineConstraints<typename Number::value_type> &constraints,
- const std::shared_ptr<const Utilities::MPI::Partitioner> & partitioner)
+ const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner)
{
std::vector<types::global_dof_index> local_dof_indices(
cell->get_fe().n_dofs_per_cell());
// dof is constrained
if (entries_ptr != nullptr)
{
- const auto & entries = *entries_ptr;
+ const auto &entries = *entries_ptr;
const types::global_dof_index n_entries = entries.size();
if (n_entries == 1 &&
std::abs(entries[0].second - 1.) <
template <typename T, typename VectorType>
inline void
ConstraintInfo<dim, Number>::read_write_operation(
- const T & operation,
- VectorType & global_vector,
- Number * local_vector,
+ const T &operation,
+ VectorType &global_vector,
+ Number *local_vector,
const unsigned int first_cell,
const unsigned int n_cells,
const unsigned int n_dofs_per_cell,
apply_for_each_quad_point(const Functor &func);
private:
- const data_type * data;
+ const data_type *data;
SharedData<dim, Number> *shared_data;
int cell_id;
};
DEAL_II_HOST_DEVICE inline bool
is_constrained_dof_2d(
const dealii::internal::MatrixFreeFunctions::ConstraintKinds
- & constraint_mask,
+ &constraint_mask,
const unsigned int x_idx,
const unsigned int y_idx)
{
DEAL_II_HOST_DEVICE inline bool
is_constrained_dof_3d(
const dealii::internal::MatrixFreeFunctions::ConstraintKinds
- & constraint_mask,
+ &constraint_mask,
const unsigned int x_idx,
const unsigned int y_idx,
const unsigned int z_idx,
Kokkos::View<Number *, MemorySpace::Default::kokkos_space>
constraint_weights,
const dealii::internal::MatrixFreeFunctions::ConstraintKinds
- & constraint_mask,
+ &constraint_mask,
Kokkos::View<Number *,
MemorySpace::Default::kokkos_space::execution_space::
scratch_memory_space,
*/
template <typename IteratorFiltersType>
void
- reinit(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ reinit(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const Quadrature<1> & quad,
- const IteratorFiltersType & iterator_filter,
- const AdditionalData & additional_data = AdditionalData());
+ const Quadrature<1> &quad,
+ const IteratorFiltersType &iterator_filter,
+ const AdditionalData &additional_data = AdditionalData());
/**
* Same as above using Iterators::LocallyOwnedCell() as predicate.
*/
void
- reinit(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ reinit(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const Quadrature<1> & quad,
- const AdditionalData & additional_data = AdditionalData());
+ const Quadrature<1> &quad,
+ const AdditionalData &additional_data = AdditionalData());
/**
* Initializes the data structures. Same as above but using a Q1 mapping.
*/
void
- reinit(const DoFHandler<dim> & dof_handler,
+ reinit(const DoFHandler<dim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const Quadrature<1> & quad,
- const AdditionalData & additional_data = AdditionalData());
+ const Quadrature<1> &quad,
+ const AdditionalData &additional_data = AdditionalData());
/**
* Return the Data structure associated with @p color.
// clang-format on
template <typename Functor, typename VectorType>
void
- cell_loop(const Functor & func,
+ cell_loop(const Functor &func,
const VectorType &src,
- VectorType & dst) const;
+ VectorType &dst) const;
/**
* This method runs the loop over all cells and apply the local operation on
*/
template <typename IteratorFiltersType>
void
- internal_reinit(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
- const AffineConstraints<Number> & constraints,
- const Quadrature<1> & quad,
- const IteratorFiltersType & iterator_filter,
+ internal_reinit(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
+ const AffineConstraints<Number> &constraints,
+ const Quadrature<1> &quad,
+ const IteratorFiltersType &iterator_filter,
const std::shared_ptr<const MPI_Comm> &comm,
const AdditionalData additional_data);
*/
template <typename Functor, typename VectorType>
void
- serial_cell_loop(const Functor & func,
+ serial_cell_loop(const Functor &func,
const VectorType &src,
- VectorType & dst) const;
+ VectorType &dst) const;
/**
* Helper function. Loop over all the cells and apply the functor on each
distributed_cell_loop(
const Functor &func,
const LinearAlgebra::distributed::Vector<Number, MemorySpace::Default>
- & src,
+ &src,
LinearAlgebra::distributed::Vector<Number, MemorySpace::Default> &dst)
const;
template <typename Functor>
void
distributed_cell_loop(
- const Functor & func,
+ const Functor &func,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src,
- LinearAlgebra::CUDAWrappers::Vector<Number> & dst) const;
+ LinearAlgebra::CUDAWrappers::Vector<Number> &dst) const;
#endif
/**
Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
DEAL_II_HOST_DEVICE
- SharedData(const TeamHandle & team_member,
+ SharedData(const TeamHandle &team_member,
const SharedView1D &values,
const SharedView2D &gradients)
: team_member(team_member)
{
public:
ReinitHelper(
- MatrixFree<dim, Number> * data,
- const Mapping<dim> & mapping,
+ MatrixFree<dim, Number> *data,
+ const Mapping<dim> &mapping,
const FiniteElement<dim, dim> &fe,
- const Quadrature<1> & quad,
+ const Quadrature<1> &quad,
const ::dealii::internal::MatrixFreeFunctions::ShapeInfo<Number>
- & shape_info,
+ &shape_info,
const DoFHandler<dim> &dof_handler,
- const UpdateFlags & update_flags);
+ const UpdateFlags &update_flags);
void
resize(const unsigned int n_colors);
void
fill_data(
const unsigned int color,
- const std::vector<CellFilter> & graph,
+ const std::vector<CellFilter> &graph,
const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
private:
std::vector<types::global_dof_index> local_dof_indices;
FEValues<dim> fe_values;
// Convert the default dof numbering to a lexicographic one
- const std::vector<unsigned int> & lexicographic_inv;
+ const std::vector<unsigned int> &lexicographic_inv;
std::vector<types::global_dof_index> lexicographic_dof_indices;
const unsigned int fe_degree;
const unsigned int dofs_per_cell;
const unsigned int q_points_per_cell;
- const UpdateFlags & update_flags;
+ const UpdateFlags &update_flags;
const unsigned int padding_length;
dealii::internal::MatrixFreeFunctions::HangingNodes<dim> hanging_nodes;
};
template <int dim, typename Number>
ReinitHelper<dim, Number>::ReinitHelper(
- MatrixFree<dim, Number> * data,
- const Mapping<dim> & mapping,
+ MatrixFree<dim, Number> *data,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<1> & quad,
+ const Quadrature<1> &quad,
const ::dealii::internal::MatrixFreeFunctions::ShapeInfo<Number>
- & shape_info,
+ &shape_info,
const DoFHandler<dim> &dof_handler,
- const UpdateFlags & update_flags)
+ const UpdateFlags &update_flags)
: data(data)
, fe_values(mapping,
fe,
void
ReinitHelper<dim, Number>::fill_data(
const unsigned int color,
- const std::vector<CellFilter> & graph,
+ const std::vector<CellFilter> &graph,
const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner)
{
const unsigned int n_cells = data->n_cells[color];
auto constraint_mask_host =
Kokkos::create_mirror_view(data->constraint_mask[color]);
- typename std::remove_reference_t<decltype(
- data->q_points[color])>::HostMirror q_points_host;
+ typename std::remove_reference_t<
+ decltype(data->q_points[color])>::HostMirror q_points_host;
typename std::remove_reference_t<decltype(data->JxW[color])>::HostMirror
- JxW_host;
- typename std::remove_reference_t<decltype(
- data->inv_jacobian[color])>::HostMirror inv_jacobian_host;
+ JxW_host;
+ typename std::remove_reference_t<
+ decltype(data->inv_jacobian[color])>::HostMirror inv_jacobian_host;
#if KOKKOS_VERSION >= 30600
auto local_to_global_host =
Kokkos::create_mirror_view(Kokkos::WithoutInitializing,
std::vector<types::global_dof_index>
get_conflict_indices(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
- & cell,
+ &cell,
const AffineConstraints<number> &constraints)
{
std::vector<types::global_dof_index> local_dof_indices(
ApplyKernel(Functor func,
const typename MatrixFree<dim, Number>::Data gpu_data,
Number *const src,
- Number * dst)
+ Number *dst)
: func(func)
, gpu_data(gpu_data)
, src(src)
Functor func;
const typename MatrixFree<dim, Number>::Data gpu_data;
Number *const src;
- Number * dst;
+ Number *dst;
// Provide the shared memory capacity. This function takes the team_size
template <int dim, typename Number>
template <typename IteratorFiltersType>
void
- MatrixFree<dim, Number>::reinit(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ MatrixFree<dim, Number>::reinit(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const Quadrature<1> & quad,
+ const Quadrature<1> &quad,
const IteratorFiltersType &iterator_filter,
- const AdditionalData & additional_data)
+ const AdditionalData &additional_data)
{
const auto &triangulation = dof_handler.get_triangulation();
if (const auto parallel_triangulation =
template <int dim, typename Number>
void
- MatrixFree<dim, Number>::reinit(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ MatrixFree<dim, Number>::reinit(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const Quadrature<1> & quad,
+ const Quadrature<1> &quad,
const AdditionalData &additional_data)
{
IteratorFilters::LocallyOwnedCell locally_owned_cell_filter;
template <int dim, typename Number>
void
- MatrixFree<dim, Number>::reinit(const DoFHandler<dim> & dof_handler,
+ MatrixFree<dim, Number>::reinit(const DoFHandler<dim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const Quadrature<1> & quad,
+ const Quadrature<1> &quad,
const AdditionalData &additional_data)
{
reinit(StaticMappingQ1<dim>::mapping,
template <typename VectorType>
void
MatrixFree<dim, Number>::copy_constrained_values(const VectorType &src,
- VectorType & dst) const
+ VectorType &dst) const
{
static_assert(
std::is_same_v<Number, typename VectorType::value_type>,
// work-around can be removed.
auto constr_dofs = constrained_dofs;
const unsigned int size = internal::VectorLocalSize<VectorType>::get(dst);
- const Number * src_ptr = src.get_values();
- Number * dst_ptr = dst.get_values();
+ const Number *src_ptr = src.get_values();
+ Number *dst_ptr = dst.get_values();
Kokkos::parallel_for(
"dealii::copy_constrained_values",
Kokkos::RangePolicy<MemorySpace::Default::kokkos_space::execution_space>(
template <int dim, typename Number>
template <typename Functor, typename VectorType>
void
- MatrixFree<dim, Number>::cell_loop(const Functor & func,
+ MatrixFree<dim, Number>::cell_loop(const Functor &func,
const VectorType &src,
- VectorType & dst) const
+ VectorType &dst) const
{
if (partitioner)
distributed_cell_loop(func, src, dst);
template <typename IteratorFiltersType>
void
MatrixFree<dim, Number>::internal_reinit(
- const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler_,
- const AffineConstraints<Number> & constraints,
- const Quadrature<1> & quad,
- const IteratorFiltersType & iterator_filter,
+ const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler_,
+ const AffineConstraints<Number> &constraints,
+ const Quadrature<1> &quad,
+ const IteratorFiltersType &iterator_filter,
const std::shared_ptr<const MPI_Comm> &comm,
const AdditionalData additional_data)
{
template <int dim, typename Number>
template <typename Functor, typename VectorType>
void
- MatrixFree<dim, Number>::serial_cell_loop(const Functor & func,
+ MatrixFree<dim, Number>::serial_cell_loop(const Functor &func,
const VectorType &src,
- VectorType & dst) const
+ VectorType &dst) const
{
// Execute the loop on the cells
for (unsigned int color = 0; color < n_colors; ++color)
DEAL_II_HOST_DEVICE
EvaluatorTensorProduct(
- const TeamHandle & team_member,
+ const TeamHandle &team_member,
Kokkos::View<Number *, MemorySpace::Default::kokkos_space> shape_values,
Kokkos::View<Number *, MemorySpace::Default::kokkos_space>
shape_gradients,
n_q_points_1d,
Number>::
EvaluatorTensorProduct(
- const TeamHandle & team_member,
+ const TeamHandle &team_member,
Kokkos::View<Number *, MemorySpace::Default::kokkos_space> shape_values,
Kokkos::View<Number *, MemorySpace::Default::kokkos_space>
shape_gradients,
const std::vector<types::global_dof_index> &local_indices_resolved,
const std::vector<types::global_dof_index> &local_indices,
const bool cell_has_hanging_nodes,
- const dealii::AffineConstraints<number> & constraints,
+ const dealii::AffineConstraints<number> &constraints,
const unsigned int cell_number,
- ConstraintValues<double> & constraint_values,
- bool & cell_at_boundary);
+ ConstraintValues<double> &constraint_values,
+ bool &cell_at_boundary);
/**
* For a given cell, determine if it has hanging node constraints. If yes,
template <int dim>
bool
process_hanging_node_constraints(
- const HangingNodes<dim> & hanging_nodes,
+ const HangingNodes<dim> &hanging_nodes,
const std::vector<std::vector<unsigned int>> &lexicographic_mapping,
const unsigned int cell_number,
const TriaIterator<DoFCellAccessor<dim, dim, false>> &cell,
- std::vector<types::global_dof_index> & dof_indices);
+ std::vector<types::global_dof_index> &dof_indices);
/**
* This method assigns the correct indices to ghost indices from the
* vectorization.
*/
void
- reorder_cells(const TaskInfo & task_info,
- const std::vector<unsigned int> & renumbering,
- const std::vector<unsigned int> & constraint_pool_row_index,
+ reorder_cells(const TaskInfo &task_info,
+ const std::vector<unsigned int> &renumbering,
+ const std::vector<unsigned int> &constraint_pool_row_index,
const std::vector<unsigned char> &irregular_cells);
/**
* fills the structure into a sparsity pattern.
*/
void
- make_connectivity_graph(const TaskInfo & task_info,
+ make_connectivity_graph(const TaskInfo &task_info,
const std::vector<unsigned int> &renumbering,
DynamicSparsityPattern &connectivity) const;
*/
void
compute_tight_partitioners(
- const Table<2, ShapeInfo<double>> & shape_info,
+ const Table<2, ShapeInfo<double>> &shape_info,
const unsigned int n_owned_cells,
const unsigned int n_lanes,
const std::vector<FaceToCellTopology<1>> &inner_faces,
template <int length>
void
compute_vector_zero_access_pattern(
- const TaskInfo & task_info,
+ const TaskInfo &task_info,
const std::vector<FaceToCellTopology<length>> &faces);
/**
*/
template <typename StreamType>
void
- print_memory_consumption(StreamType & out,
+ print_memory_consumption(StreamType &out,
const TaskInfo &size_info) const;
/**
*/
template <typename Number>
void
- print(const std::vector<Number> & constraint_pool_data,
+ print(const std::vector<Number> &constraint_pool_data,
const std::vector<unsigned int> &constraint_pool_row_index,
- std::ostream & out) const;
+ std::ostream &out) const;
/**
* Enum for various storage variants of the indices. This storage format
const std::vector<types::global_dof_index> &local_indices_resolved,
const std::vector<types::global_dof_index> &local_indices,
const bool cell_has_hanging_nodes,
- const dealii::AffineConstraints<number> & constraints,
+ const dealii::AffineConstraints<number> &constraints,
const unsigned int cell_number,
- ConstraintValues<double> & constraint_values,
- bool & cell_at_subdomain_boundary)
+ ConstraintValues<double> &constraint_values,
+ bool &cell_at_subdomain_boundary)
{
Assert(vector_partitioner.get() != nullptr, ExcInternalError());
const types::global_dof_index first_owned =
for (; i < next; ++i)
{
types::global_dof_index current_dof = local_indices_resolved[i];
- const auto * entries_ptr =
+ const auto *entries_ptr =
constraints.get_constraint_entries(current_dof);
// dof is constrained
// check whether this dof is identity constrained to another
// dof. then we can simply insert that dof and there is no
// need to actually resolve the constraint entries
- const auto & entries = *entries_ptr;
+ const auto &entries = *entries_ptr;
const types::global_dof_index n_entries = entries.size();
if (n_entries == 1 &&
std::abs(entries[0].second - 1.) <
template <int dim>
bool
DoFInfo::process_hanging_node_constraints(
- const HangingNodes<dim> & hanging_nodes,
+ const HangingNodes<dim> &hanging_nodes,
const std::vector<std::vector<unsigned int>> &lexicographic_mapping,
const unsigned int cell_number,
const TriaIterator<DoFCellAccessor<dim, dim, false>> &cell,
- std::vector<types::global_dof_index> & dof_indices)
+ std::vector<types::global_dof_index> &dof_indices)
{
if (this->hanging_node_constraint_masks_comp.empty())
return false;
template <int length>
void
DoFInfo::compute_vector_zero_access_pattern(
- const TaskInfo & task_info,
+ const TaskInfo &task_info,
const std::vector<FaceToCellTopology<length>> &faces)
{
// compute a list that tells us the first time a degree of freedom is
template <typename StreamType>
void
- DoFInfo::print_memory_consumption(StreamType & out,
+ DoFInfo::print_memory_consumption(StreamType &out,
const TaskInfo &task_info) const
{
out << " Memory row starts indices: ";
template <typename Number>
void
- DoFInfo::print(const std::vector<Number> & constraint_pool_data,
+ DoFInfo::print(const std::vector<Number> &constraint_pool_data,
const std::vector<unsigned int> &constraint_pool_row_index,
- std::ostream & out) const
+ std::ostream &out) const
{
const unsigned int n_rows = row_starts.size() - 1;
for (unsigned int row = 0; row < n_rows; ++row)
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval);
+ const Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval);
static void
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array);
static Eval
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval);
+ const Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval);
static void
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array);
};
static void
evaluate_or_integrate(
const EvaluationFlags::EvaluationFlags evaluation_flag,
- Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array = false);
private:
static void
evaluate_tensor_product_per_component(
const EvaluationFlags::EvaluationFlags evaluation_flag,
- Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array,
std::integral_constant<bool, false>);
static void
evaluate_tensor_product_per_component(
const EvaluationFlags::EvaluationFlags evaluation_flag,
- Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array,
std::integral_constant<bool, true>);
};
FEEvaluationImpl<type, dim, fe_degree, n_q_points_1d, Number>::evaluate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval)
+ const Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval)
{
if (evaluation_flag == EvaluationFlags::nothing)
return;
FEEvaluationImpl<type, dim, fe_degree, n_q_points_1d, Number>::integrate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array)
{
std::array<const MatrixFreeFunctions::UnivariateShapeData<Number2> *, 3>
n_q_points_1d,
Number>::evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval)
+ const Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval)
{
Assert(!(evaluation_flag & EvaluationFlags::hessians), ExcNotImplemented());
if (evaluation_flag & EvaluationFlags::values)
{
const auto *const shape_values = shape_data.front().shape_values.data();
- auto * values_quad_ptr = fe_eval.begin_values();
- const auto * values_dofs_actual_ptr = values_dofs_actual;
+ auto *values_quad_ptr = fe_eval.begin_values();
+ const auto *values_dofs_actual_ptr = values_dofs_actual;
Eval eval(shape_values, nullptr, nullptr, n_dofs, n_q_points);
for (unsigned int c = 0; c < n_components; ++c)
{
const auto *const shape_gradients =
shape_data.front().shape_gradients.data();
- auto * gradients_quad_ptr = fe_eval.begin_gradients();
+ auto *gradients_quad_ptr = fe_eval.begin_gradients();
const auto *values_dofs_actual_ptr = values_dofs_actual;
for (unsigned int c = 0; c < n_components; ++c)
n_q_points_1d,
Number>::integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs_actual,
+ Number *values_dofs_actual,
FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array)
{
if (integration_flag & EvaluationFlags::values)
{
const auto *const shape_values = shape_data.front().shape_values.data();
- auto * values_quad_ptr = fe_eval.begin_values();
- auto * values_dofs_actual_ptr = values_dofs_actual;
+ auto *values_quad_ptr = fe_eval.begin_values();
+ auto *values_dofs_actual_ptr = values_dofs_actual;
Eval eval(shape_values, nullptr, nullptr, n_dofs, n_q_points);
for (unsigned int c = 0; c < n_components; ++c)
Number>::
evaluate_or_integrate(
const EvaluationFlags::EvaluationFlags evaluation_flag,
- Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array)
{
if (evaluation_flag == EvaluationFlags::nothing)
Number>::
evaluate_tensor_product_per_component(
const EvaluationFlags::EvaluationFlags evaluation_flag,
- Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array,
std::integral_constant<bool, false>)
{
Number>::
evaluate_tensor_product_per_component(
const EvaluationFlags::EvaluationFlags evaluation_flag,
- Number * values_dofs_actual,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array,
std::integral_constant<bool, true>)
{
static void
do_forward(const unsigned int n_components,
const AlignedVector<Number2> &transformation_matrix,
- const Number * values_in,
- Number * values_out,
+ const Number *values_in,
+ Number *values_out,
const unsigned int basis_size_1_variable =
numbers::invalid_unsigned_int,
const unsigned int basis_size_2_variable =
Number,
Number2>
eval_val(transformation_matrix,
- {},
- {},
+ {},
+ {},
basis_size_1_variable,
basis_size_2_variable);
const unsigned int np_1 =
do_backward(const unsigned int n_components,
const AlignedVector<Number2> &transformation_matrix,
const bool add_into_result,
- Number * values_in,
- Number * values_out,
+ Number *values_in,
+ Number *values_out,
const unsigned int basis_size_1_variable =
numbers::invalid_unsigned_int,
const unsigned int basis_size_2_variable =
static void
do_mass(const unsigned int n_components,
const AlignedVector<Number2> &transformation_matrix,
- const AlignedVector<Number> & coefficients,
- const Number * values_in,
- Number * scratch_data,
- Number * values_out)
+ const AlignedVector<Number> &coefficients,
+ const Number *values_in,
+ Number *scratch_data,
+ Number *values_out)
{
constexpr int next_dim = dim > 1 ? dim - 1 : dim;
- Number * my_scratch =
+ Number *my_scratch =
basis_size_1 != basis_size_2 ? scratch_data : values_out;
const unsigned int size_per_component = Utilities::pow(basis_size_2, dim);
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval);
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval);
static void
do_evaluate(const MatrixFreeFunctions::UnivariateShapeData<Number2> &shape,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- Number * gradients_quad,
- Number * hessians_quad);
+ const Number *values_dofs,
+ Number *gradients_quad,
+ Number *hessians_quad);
static void
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array);
static void
do_integrate(const MatrixFreeFunctions::UnivariateShapeData<Number2> &shape,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- Number * gradients_quad,
- const Number * hessians_quad,
+ Number *values_dofs,
+ Number *gradients_quad,
+ const Number *hessians_quad,
const bool add_into_values_array);
};
FEEvaluationImplCollocation<dim, fe_degree, Number>::evaluate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval)
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval)
{
constexpr std::size_t n_points = Utilities::pow(fe_degree + 1, dim);
FEEvaluationImplCollocation<dim, fe_degree, Number>::do_evaluate(
const MatrixFreeFunctions::UnivariateShapeData<Number2> &shape,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- Number * gradients_quad,
- Number * hessians_quad)
+ const Number *values_dofs,
+ Number *gradients_quad,
+ Number *hessians_quad)
{
AssertDimension(shape.shape_gradients_collocation_eo.size(),
(fe_degree + 2) / 2 * (fe_degree + 1));
FEEvaluationImplCollocation<dim, fe_degree, Number>::integrate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array)
{
constexpr std::size_t n_points = Utilities::pow(fe_degree + 1, dim);
FEEvaluationImplCollocation<dim, fe_degree, Number>::do_integrate(
const MatrixFreeFunctions::UnivariateShapeData<Number2> &shape,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- Number * gradients_quad,
- const Number * hessians_quad,
+ Number *values_dofs,
+ Number *gradients_quad,
+ const Number *hessians_quad,
const bool add_into_values_array)
{
AssertDimension(shape.shape_gradients_collocation_eo.size(),
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval);
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval);
static void
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array);
};
n_q_points_1d,
Number>::evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval)
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval)
{
const auto &shape_data = fe_eval.get_shape_info().data.front();
n_q_points_1d,
Number>::integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool add_into_values_array)
{
const auto &shape_data = fe_eval.get_shape_info().data.front();
static bool
run(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- OtherNumber * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ OtherNumber *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool sum_into_values_array = false)
{
// `OtherNumber` is either `const Number` (evaluate()) or `Number`
evaluate_or_integrate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool sum_into_values_array,
std::integral_constant<bool, false>)
{
evaluate_or_integrate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool sum_into_values_array,
std::integral_constant<bool, true>)
{
evaluate_or_integrate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- OtherNumber * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ OtherNumber *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool sum_into_values_array)
{
evaluate_or_integrate<T>(n_components,
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const MatrixFreeFunctions::UnivariateShapeData<Number2> &data,
- Number * values_dofs,
- Number * values_quad,
- Number * gradients_quad,
- Number * hessians_quad,
- Number * scratch_data,
+ Number *values_dofs,
+ Number *values_quad,
+ Number *gradients_quad,
+ Number *hessians_quad,
+ Number *scratch_data,
const unsigned int subface_index)
{
Eval eval0 = create_evaluator_tensor_product(data, subface_index, 0);
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
const MatrixFreeFunctions::UnivariateShapeData<Number2> &data,
- Number * values_dofs,
- Number * values_quad,
- Number * gradients_quad,
- Number * hessians_quad,
- Number * scratch_data,
+ Number *values_dofs,
+ Number *values_quad,
+ Number *gradients_quad,
+ Number *hessians_quad,
+ Number *scratch_data,
const unsigned int subface_index)
{
Eval eval0 = create_evaluator_tensor_product(data, subface_index, 0);
static void
evaluate_or_integrate_in_face(
const EvaluationFlags::EvaluationFlags evaluation_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, true> & fe_eval,
- Number * scratch_data,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, true> &fe_eval,
+ Number *scratch_data,
const unsigned int subface_index,
const unsigned int face_no)
{
template <int normal_dir>
static inline void
evaluate_in_face_apply(
- Number * values_dofs,
- FEEvaluationData<dim, Number, true> & fe_eval,
- Number * scratch_data,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, true> &fe_eval,
+ Number *scratch_data,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const unsigned int face_direction,
const unsigned int subface_index,
template <int normal_dir>
static inline void
evaluate_in_face_apply(
- Number * values_dofs,
- FEEvaluationData<dim, Number, true> & fe_eval,
- Number * scratch_data,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, true> &fe_eval,
+ Number *scratch_data,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const unsigned int face_direction,
const unsigned int subface_index,
interpolate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags flags,
const MatrixFreeFunctions::ShapeInfo<Number2> &shape_info,
- const Number * input,
- Number * output,
+ const Number *input,
+ Number *output,
const unsigned int face_no)
{
Assert(static_cast<unsigned int>(fe_degree) ==
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags flags,
const MatrixFreeFunctions::ShapeInfo<Number2> &shape_info,
- const Number * input,
- Number * output,
+ const Number *input,
+ Number *output,
const unsigned int face_no)
{
Assert(static_cast<unsigned int>(fe_degree + 1) ==
template <bool do_evaluate, bool add_into_output, int face_direction = 0>
static void
interpolate_generic(const unsigned int n_components,
- const Number * input,
- Number * output,
+ const Number *input,
+ Number *output,
const EvaluationFlags::EvaluationFlags flag,
const unsigned int face_no,
const unsigned int n_points_1d,
static void
interpolate_generic_raviart_thomas(
const unsigned int n_components,
- const Number * input,
- Number * output,
+ const Number *input,
+ Number *output,
const EvaluationFlags::EvaluationFlags flag,
const unsigned int face_no,
const MatrixFreeFunctions::ShapeInfo<Number2> &shape_info)
interpolate_generic_raviart_thomas_apply_face(
const MatrixFreeFunctions::ShapeInfo<Number2> &shape_info,
const unsigned int face_no,
- const Number * input,
- Number * output)
+ const Number *input,
+ Number *output)
{
// These types are evaluators in either normal or tangential direction
// depending on the face direction, with different normal directions for
// internal helper function for reading data; base version of different types
template <typename VectorizedArrayType, typename Number2>
void
- do_vectorized_gather(const Number2 * src_ptr,
- const unsigned int * indices,
+ do_vectorized_gather(const Number2 *src_ptr,
+ const unsigned int *indices,
VectorizedArrayType &dst)
{
for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
// can use a dedicated gather function
template <typename Number, std::size_t width>
void
- do_vectorized_gather(const Number * src_ptr,
- const unsigned int * indices,
+ do_vectorized_gather(const Number *src_ptr,
+ const unsigned int *indices,
VectorizedArray<Number, width> &dst)
{
dst.gather(src_ptr, indices);
template <typename VectorizedArrayType, typename Number2>
void
do_vectorized_scatter_add(const VectorizedArrayType src,
- const unsigned int * indices,
- Number2 * dst_ptr)
+ const unsigned int *indices,
+ Number2 *dst_ptr)
{
for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
dst_ptr[indices[v]] += src[v];
template <typename Number, std::size_t width>
void
do_vectorized_scatter_add(const VectorizedArray<Number, width> src,
- const unsigned int * indices,
- Number * dst_ptr)
+ const unsigned int *indices,
+ Number *dst_ptr)
{
#if DEAL_II_VECTORIZATION_WIDTH_IN_BITS < 512
for (unsigned int v = 0; v < width; ++v)
const unsigned int *orientation,
const bool integrate,
const std::size_t n_q_points,
- Number * tmp_values,
- Number * values_quad,
- Number * gradients_quad,
- Number * hessians_quad)
+ Number *tmp_values,
+ Number *values_quad,
+ Number *gradients_quad,
+ Number *hessians_quad)
{
for (unsigned int c = 0; c < n_components; ++c)
{
const unsigned int n_components,
const unsigned int v,
const EvaluationFlags::EvaluationFlags flag,
- const unsigned int * orientation,
+ const unsigned int *orientation,
const bool integrate,
const std::size_t n_q_points,
- Number * tmp_values,
- VectorizedArrayType * values_quad,
- VectorizedArrayType * gradients_quad = nullptr,
- VectorizedArrayType * hessians_quad = nullptr)
+ Number *tmp_values,
+ VectorizedArrayType *values_quad,
+ VectorizedArrayType *gradients_quad = nullptr,
+ VectorizedArrayType *hessians_quad = nullptr)
{
for (unsigned int c = 0; c < n_components; ++c)
{
static bool
run(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, true> & fe_eval)
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, true> &fe_eval)
{
const auto &shape_info = fe_eval.get_shape_info();
const auto &shape_data = shape_info.data.front();
if (evaluation_flag & EvaluationFlags::gradients)
{
- auto * gradients_quad_ptr = fe_eval.begin_gradients();
+ auto *gradients_quad_ptr = fe_eval.begin_gradients();
const auto *values_dofs_actual_ptr = values_dofs;
std::array<const Number2 *, dim> shape_gradients;
static bool
run(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, true> & fe_eval)
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, true> &fe_eval)
{
const auto &shape_info = fe_eval.get_shape_info();
const auto &shape_data = shape_info.data.front();
const bool check_face_orientations = false>
void
fe_face_evaluation_process_and_io(
- Processor & proc,
+ Processor &proc,
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- typename Processor::Number2_ * global_vector_ptr,
+ typename Processor::Number2_ *global_vector_ptr,
const std::vector<ArrayView<const typename Processor::Number2_>> *sm_ptr,
- const EvaluationData & fe_eval,
- typename Processor::VectorizedArrayType_ * temp1)
+ const EvaluationData &fe_eval,
+ typename Processor::VectorizedArrayType_ *temp1)
{
constexpr int dim = Processor::dim_;
constexpr int fe_degree = Processor::fe_degree_;
using Number = typename Processor::Number_;
using Number2_ = typename Processor::Number2_;
- const auto & shape_data = fe_eval.get_shape_info().data.front();
+ const auto &shape_data = fe_eval.get_shape_info().data.front();
constexpr bool integrate = Processor::do_integrate;
const unsigned int face_no = fe_eval.get_face_no();
- const auto & dof_info = fe_eval.get_dof_info();
+ const auto &dof_info = fe_eval.get_dof_info();
const unsigned int cell = fe_eval.get_cell_or_face_batch_id();
const MatrixFreeFunctions::DoFInfo::DoFAccessIndex dof_access_index =
fe_eval.get_dof_access_index();
static bool
run(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number2 * src_ptr,
- const std::vector<ArrayView<const Number2>> * sm_ptr,
+ const Number2 *src_ptr,
+ const std::vector<ArrayView<const Number2>> *sm_ptr,
FEEvaluationData<dim, VectorizedArrayType, true> &fe_eval)
{
Assert(fe_degree > -1, ExcInternalError());
template <typename Number3>
static bool
supports(const EvaluationFlags::EvaluationFlags evaluation_flag,
- const MatrixFreeFunctions::ShapeInfo<Number3> & shape_info,
- const Number2 * vector_ptr,
+ const MatrixFreeFunctions::ShapeInfo<Number3> &shape_info,
+ const Number2 *vector_ptr,
MatrixFreeFunctions::DoFInfo::IndexStorageVariants storage)
{
const unsigned int fe_degree = shape_info.data.front().fe_degree;
template <typename T0, typename T1, typename T2>
void
- hermite_grad_vectorized(T0 & temp_1,
- T0 & temp_2,
+ hermite_grad_vectorized(T0 &temp_1,
+ T0 &temp_2,
const T1 src_ptr_1,
const T1 src_ptr_2,
const T2 &grad_weight)
template <typename T0, typename T1, typename T2, typename T3>
void
- hermite_grad_vectorized_indexed(T0 & temp_1,
- T0 & temp_2,
+ hermite_grad_vectorized_indexed(T0 &temp_1,
+ T0 &temp_2,
const T1 src_ptr_1,
const T1 src_ptr_2,
const T2 &grad_weight,
template <typename T0, typename T1, typename T2>
void
- hermite_grad(T0 & temp_1,
- T0 & temp_2,
+ hermite_grad(T0 &temp_1,
+ T0 &temp_2,
const T1 &src_ptr_1,
const T1 &src_ptr_2,
const T2 &grad_weight)
static bool
run(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number2 * dst_ptr,
- const std::vector<ArrayView<const Number2>> * sm_ptr,
+ Number2 *dst_ptr,
+ const std::vector<ArrayView<const Number2>> *sm_ptr,
FEEvaluationData<dim, VectorizedArrayType, true> &fe_eval)
{
Assert(fe_degree > -1, ExcInternalError());
void
hermite_grad(const T0 &temp_1,
const T0 &temp_2,
- T1 & dst_ptr_1,
- T1 & dst_ptr_2,
+ T1 &dst_ptr_1,
+ T1 &dst_ptr_2,
const T2 &grad_weight)
{
// case 3a)
static bool
run(const unsigned int n_components,
const FEEvaluationData<dim, Number, false> &fe_eval,
- const Number * in_array,
- Number * out_array)
+ const Number *in_array,
+ Number *out_array)
{
const unsigned int given_degree =
(fe_degree > -1) ? fe_degree :
for (unsigned int d = 0; d < n_components; ++d)
{
const Number *in = in_array + d * dofs_per_component;
- Number * out = out_array + d * dofs_per_component;
+ Number *out = out_array + d * dofs_per_component;
// Need to select 'apply' method with hessian slot because values
// assume symmetries that do not exist in the inverse shapes
evaluator.template hessians<0, true, false>(in, out);
static bool
run(const unsigned int n_desired_components,
const FEEvaluationData<dim, Number, false> &fe_eval,
- const ArrayView<const Number> & inverse_coefficients,
+ const ArrayView<const Number> &inverse_coefficients,
const bool dyadic_coefficients,
- const Number * in_array,
- Number * out_array)
+ const Number *in_array,
+ Number *out_array)
{
const unsigned int given_degree =
(fe_degree > -1) ? fe_degree :
given_degree + 1);
const Number *in = in_array;
- Number * out = out_array;
+ Number *out = out_array;
const Number *inv_coefficient = inverse_coefficients.data();
for (unsigned int di = 0; di < n_comp_inner; ++di)
{
const Number *in_ = in + di * dofs_per_component;
- Number * out_ = out + di * dofs_per_component;
+ Number *out_ = out + di * dofs_per_component;
evaluator.template hessians<0, true, false>(in_, out_);
if (dim > 1)
evaluator.template hessians<1, true, false>(out_, out_);
private:
template <int n_components>
static inline void
- vmult(const Number * inverse_coefficients,
- const Number * src,
- Number * dst,
+ vmult(const Number *inverse_coefficients,
+ const Number *src,
+ Number *dst,
const unsigned int dofs_per_component,
const unsigned int n_given_components = 0)
{
static bool
run(const unsigned int n_desired_components,
const FEEvaluationData<dim, Number, false> &fe_eval,
- const Number * in_array,
- Number * out_array)
+ const Number *in_array,
+ Number *out_array)
{
static const bool do_inplace =
fe_degree > -1 && (fe_degree + 1 == n_q_points_1d);
for (unsigned int d = 0; d < n_desired_components; ++d)
{
const Number *in = in_array + d * n_q_points;
- Number * out = out_array + d * dofs_per_component;
+ Number *out = out_array + d * dofs_per_component;
auto *temp_1 = do_inplace ? out : fe_eval.get_scratch_data().begin();
auto *temp_2 = do_inplace ?
const unsigned int n_components,
const MatrixFreeFunctions::ShapeInfo<Number> &shape_info,
const std::array<MatrixFreeFunctions::compressed_constraint_kind,
- Number::size()> & constraint_mask,
- Number * values)
+ Number::size()> &constraint_mask,
+ Number *values)
{
const unsigned int given_degree =
fe_degree != -1 ? fe_degree : shape_info.data.front().fe_degree;
}
static inline DEAL_II_ALWAYS_INLINE_RELEASE void
- set_value(T1 & result,
+ set_value(T1 &result,
const typename T1::value_type &value,
- const index_type & i)
+ const index_type &i)
{
result[i] = value;
}
public:
inline DEAL_II_ALWAYS_INLINE_RELEASE
HelperBase(
- const T & t,
- const unsigned int & given_degree,
- const bool & type_x,
- const bool & type_y,
- const bool & type_z,
+ const T &t,
+ const unsigned int &given_degree,
+ const bool &type_x,
+ const bool &type_y,
+ const bool &type_z,
const typename Trait<Number, VectorizationType>::index_type &v,
const std::array<
AlignedVector<
typename Trait<Number, VectorizationType>::interpolation_type>,
- 2> & interpolation_matrices,
+ 2> &interpolation_matrices,
Number *values)
: t(t)
, given_degree(given_degree)
}
private:
- const T & t;
- const unsigned int & given_degree;
- const bool & type_x;
- const bool & type_y;
- const bool & type_z;
+ const T &t;
+ const unsigned int &given_degree;
+ const bool &type_x;
+ const bool &type_y;
+ const bool &type_z;
const typename Trait<Number, VectorizationType>::index_type &v;
const std::array<
AlignedVector<
typename Trait<Number, VectorizationType>::interpolation_type>,
- 2> & interpolation_matrices;
+ 2> &interpolation_matrices;
Number *values;
};
public:
inline DEAL_II_ALWAYS_INLINE_RELEASE
Helper(const unsigned int &given_degree,
- const bool & type_x,
- const bool & type_y,
- const bool & type_z,
+ const bool &type_x,
+ const bool &type_y,
+ const bool &type_z,
const typename Trait<Number, VectorizationType>::index_type &v,
const std::array<
AlignedVector<
typename Trait<Number, VectorizationType>::interpolation_type>,
- 2> & interpolation_matrices,
+ 2> &interpolation_matrices,
Number *values)
: HelperBase<Helper<HelperType::dynamic,
Number,
{{0, points *points - points, 0, points *points - points}}}}}},
{{{{{{points * points * points - points * points,
points *points *points - points *points + points - 1,
- points * points - points,
- points * points - 1}},
+ points *points - points,
+ points *points - 1}},
{{0, points - 1, points *points - points, points *points - 1}}}},
{{{{points * points * points - points * points,
points *points *points - points *points + points - 1,
const dealii::ndarray<unsigned int, 3, 2, 2, 3> lines_array = {
{{{{{{{points * points - points,
points *points *points - points *points,
- points *points *points - points}},
+ points *points *points - points}},
{{0, points *points - points, points *points *points - points}}}},
{{{{0,
points *points *points - points *points,
- points *points *points - points}},
+ points *points *points - points}},
{{0,
- points *points - points,
+ points *points - points,
points *points *points - points *points}}}}}},
{{{{{{points - 1,
points *points *points - points *points,
public:
inline DEAL_II_ALWAYS_INLINE_RELEASE
Helper(const unsigned int &given_degree,
- const bool & type_x,
- const bool & type_y,
- const bool & type_z,
+ const bool &type_x,
+ const bool &type_y,
+ const bool &type_z,
const typename Trait<Number, VectorizationType>::index_type &v,
const std::array<
AlignedVector<
typename Trait<Number, VectorizationType>::interpolation_type>,
- 2> & interpolation_matrices,
+ 2> &interpolation_matrices,
Number *values)
: HelperBase<Helper<HelperType::constant,
Number,
const unsigned int n_desired_components,
const MatrixFreeFunctions::ShapeInfo<Number> &shape_info,
const std::array<MatrixFreeFunctions::compressed_constraint_kind,
- Number::size()> & constraint_mask,
- Number * values)
+ Number::size()> &constraint_mask,
+ Number *values)
{
const unsigned int given_degree =
fe_degree != -1 ? fe_degree : shape_info.data.front().fe_degree;
const MatrixFreeFunctions::ShapeInfo<Number> &shape_info,
const bool transpose,
const std::array<MatrixFreeFunctions::compressed_constraint_kind,
- Number::size()> & c_mask,
- Number * values)
+ Number::size()> &c_mask,
+ Number *values)
{
using RunnerType =
FEEvaluationImplHangingNodesRunner<used_runner_type<fe_degree>(),
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, false> & eval);
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &eval);
/**
* Chooses an appropriate evaluation strategy for the integrate function, i.e.
static void
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, false> & eval,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &eval,
const bool sum_into_values_array = false);
};
SelectEvaluator<dim, fe_degree, n_q_points_1d, Number>::evaluate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, false> & eval)
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &eval)
{
Assert(fe_degree >= 0 && n_q_points_1d > 0, ExcInternalError());
SelectEvaluator<dim, fe_degree, n_q_points_1d, Number>::integrate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, false> & eval,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &eval,
const bool sum_into_values_array)
{
Assert(fe_degree >= 0 && n_q_points_1d > 0, ExcInternalError());
FEFaceEvaluationFactory<dim, Number>::evaluate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, true> & fe_eval)
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, true> &fe_eval)
{
instantiation_helper_run<1,
FEFaceEvaluationImplEvaluateSelector<dim, Number>>(
FEFaceEvaluationFactory<dim, Number>::integrate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, true> & fe_eval)
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, true> &fe_eval)
{
instantiation_helper_run<
1,
FEFaceEvaluationGatherFactory<dim, Number, VectorizedArrayType>::evaluate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * src_ptr,
- const std::vector<ArrayView<const Number>> * sm_ptr,
+ const Number *src_ptr,
+ const std::vector<ArrayView<const Number>> *sm_ptr,
FEEvaluationData<dim, VectorizedArrayType, true> &fe_eval)
{
instantiation_helper_run<
FEFaceEvaluationGatherFactory<dim, Number, VectorizedArrayType>::integrate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * dst_ptr,
- const std::vector<ArrayView<const Number>> * sm_ptr,
+ Number *dst_ptr,
+ const std::vector<ArrayView<const Number>> *sm_ptr,
FEEvaluationData<dim, VectorizedArrayType, true> &fe_eval)
{
instantiation_helper_run<
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval);
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval);
static void
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool sum_into_values_array);
static bool
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, true> & fe_eval);
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, true> &fe_eval);
static void
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, true> & fe_eval);
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, true> &fe_eval);
static bool
fast_evaluation_supported(const unsigned int given_degree,
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * src_ptr,
- const std::vector<ArrayView<const Number>> * sm_ptr,
+ const Number *src_ptr,
+ const std::vector<ArrayView<const Number>> *sm_ptr,
FEEvaluationData<dim, VectorizedArrayType, true> &fe_eval);
static void
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * dst_ptr,
+ Number *dst_ptr,
const std::vector<ArrayView<const Number>> *sm_ptr,
FEEvaluationData<dim, VectorizedArrayType, true> &fe_eval);
};
static void
apply(const unsigned int n_components,
const FEEvaluationData<dim, Number, false> &fe_eval,
- const Number * in_array,
- Number * out_array);
+ const Number *in_array,
+ Number *out_array);
static void
apply(const unsigned int n_components,
const FEEvaluationData<dim, Number, false> &fe_eval,
- const ArrayView<const Number> & inverse_coefficients,
+ const ArrayView<const Number> &inverse_coefficients,
const bool dyadic_coefficients,
- const Number * in_array,
- Number * out_array);
+ const Number *in_array,
+ Number *out_array);
static void
transform_from_q_points_to_basis(
const unsigned int n_components,
const FEEvaluationData<dim, Number, false> &fe_eval,
- const Number * in_array,
- Number * out_array);
+ const Number *in_array,
+ Number *out_array);
};
template <int dim,
const MatrixFreeFunctions::ShapeInfo<VectorizedArrayType> &shape_info,
const bool transpose,
const std::array<MatrixFreeFunctions::compressed_constraint_kind,
- VectorizedArrayType::size()> & c_mask,
- VectorizedArrayType * values);
+ VectorizedArrayType::size()> &c_mask,
+ VectorizedArrayType *values);
};
} // end of namespace internal
FEEvaluationFactory<dim, Number>::evaluate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval)
+ const Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval)
{
instantiation_helper_run<1, FEEvaluationImplSelector<dim, Number, false>>(
fe_eval.get_shape_info().data[0].fe_degree,
FEEvaluationFactory<dim, Number>::integrate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- FEEvaluationData<dim, Number, false> & fe_eval,
+ Number *values_dofs,
+ FEEvaluationData<dim, Number, false> &fe_eval,
const bool sum_into_values_array)
{
instantiation_helper_run<1, FEEvaluationImplSelector<dim, Number, true>>(
CellwiseInverseMassFactory<dim, Number>::apply(
const unsigned int n_components,
const FEEvaluationData<dim, Number, false> &fe_eval,
- const Number * in_array,
- Number * out_array)
+ const Number *in_array,
+ Number *out_array)
{
const unsigned int fe_degree = fe_eval.get_shape_info().data[0].fe_degree;
instantiation_helper_run<1,
CellwiseInverseMassFactory<dim, Number>::apply(
const unsigned int n_components,
const FEEvaluationData<dim, Number, false> &fe_eval,
- const ArrayView<const Number> & inverse_coefficients,
+ const ArrayView<const Number> &inverse_coefficients,
const bool dyadic_coefficients,
- const Number * in_array,
- Number * out_array)
+ const Number *in_array,
+ Number *out_array)
{
const unsigned int fe_degree = fe_eval.get_shape_info().data[0].fe_degree;
instantiation_helper_run<
CellwiseInverseMassFactory<dim, Number>::transform_from_q_points_to_basis(
const unsigned int n_components,
const FEEvaluationData<dim, Number, false> &fe_eval,
- const Number * in_array,
- Number * out_array)
+ const Number *in_array,
+ Number *out_array)
{
const unsigned int fe_degree = fe_eval.get_shape_info().data[0].fe_degree;
const unsigned int n_q_points_1d =
const MatrixFreeFunctions::ShapeInfo<VectorizedArrayType> &shape_info,
const bool transpose,
const std::array<MatrixFreeFunctions::compressed_constraint_kind,
- VectorizedArrayType::size()> & c_mask,
- VectorizedArrayType * values)
+ VectorizedArrayType::size()> &c_mask,
+ VectorizedArrayType *values)
{
instantiation_helper_degree_run<
1,
*/
void
generate_faces(
- const dealii::Triangulation<dim> & triangulation,
+ const dealii::Triangulation<dim> &triangulation,
const std::vector<std::pair<unsigned int, unsigned int>> &cell_levels,
- TaskInfo & task_info);
+ TaskInfo &task_info);
/**
* Fills the information about the cell, the face number, and numbers
void
collect_faces_vectorization(
const std::vector<FaceToCellTopology<1>> &faces_in,
- const std::vector<bool> & hard_vectorization_boundary,
- std::vector<unsigned int> & face_partition_data,
+ const std::vector<bool> &hard_vectorization_boundary,
+ std::vector<unsigned int> &face_partition_data,
std::vector<FaceToCellTopology<vectorization_width>> &faces_out);
template <int dim>
void
FaceSetup<dim>::generate_faces(
- const dealii::Triangulation<dim> & triangulation,
+ const dealii::Triangulation<dim> &triangulation,
const std::vector<std::pair<unsigned int, unsigned int>> &cell_levels,
- TaskInfo & task_info)
+ TaskInfo &task_info)
{
const bool is_mixed_mesh = triangulation.is_mixed_mesh();
*/
inline bool
compare_faces_for_vectorization(
- const FaceToCellTopology<1> & face1,
- const FaceToCellTopology<1> & face2,
+ const FaceToCellTopology<1> &face1,
+ const FaceToCellTopology<1> &face2,
const std::vector<unsigned int> &active_fe_indices,
const unsigned int length)
{
void
collect_faces_vectorization(
const std::vector<FaceToCellTopology<1>> &faces_in,
- const std::vector<bool> & hard_vectorization_boundary,
- std::vector<unsigned int> & face_partition_data,
+ const std::vector<bool> &hard_vectorization_boundary,
+ std::vector<unsigned int> &face_partition_data,
std::vector<FaceToCellTopology<vectorization_width>> &faces_out,
- const std::vector<unsigned int> & active_fe_indices)
+ const std::vector<unsigned int> &active_fe_indices)
{
FaceToCellTopology<vectorization_width> face_batch;
std::vector<std::vector<unsigned int>> faces_type;
template <typename VectorType>
void
read_dof_values(
- const VectorType & src,
+ const VectorType &src,
const unsigned int first_index = 0,
const std::bitset<n_lanes> &mask = std::bitset<n_lanes>().flip());
template <typename VectorType>
void
read_dof_values_plain(
- const VectorType & src,
+ const VectorType &src,
const unsigned int first_index = 0,
const std::bitset<n_lanes> &mask = std::bitset<n_lanes>().flip());
template <typename VectorType>
void
distribute_local_to_global(
- VectorType & dst,
+ VectorType &dst,
const unsigned int first_index = 0,
const std::bitset<n_lanes> &mask = std::bitset<n_lanes>().flip()) const;
template <typename VectorType>
void
set_dof_values(
- VectorType & dst,
+ VectorType &dst,
const unsigned int first_index = 0,
const std::bitset<n_lanes> &mask = std::bitset<n_lanes>().flip()) const;
template <typename VectorType>
void
set_dof_values_plain(
- VectorType & dst,
+ VectorType &dst,
const unsigned int first_index = 0,
const std::bitset<n_lanes> &mask = std::bitset<n_lanes>().flip()) const;
* conditions.
*/
FEEvaluationBase(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
const FEEvaluationData<dim, VectorizedArrayType, is_face> *other);
template <typename VectorType, typename VectorOperation>
void
read_write_operation(
- const VectorOperation & operation,
+ const VectorOperation &operation,
const std::array<VectorType *, n_components_> &vectors,
const std::array<
const std::vector<ArrayView<const typename VectorType::value_type>> *,
- n_components_> & vectors_sm,
+ n_components_> &vectors_sm,
const std::bitset<n_lanes> &mask,
const bool apply_constraints = true) const;
template <typename VectorType, typename VectorOperation>
void
read_write_operation_contiguous(
- const VectorOperation & operation,
+ const VectorOperation &operation,
const std::array<VectorType *, n_components_> &vectors,
const std::array<
const std::vector<ArrayView<const typename VectorType::value_type>> *,
- n_components_> & vectors_sm,
+ n_components_> &vectors_sm,
const std::bitset<n_lanes> &mask) const;
/**
template <typename VectorType, typename VectorOperation>
void
read_write_operation_global(
- const VectorOperation & operation,
+ const VectorOperation &operation,
const std::array<VectorType *, n_components_> &vectors) const;
/**
* as FEValues, including matrix assembly.
*/
FEEvaluationAccess(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
const FEEvaluationData<dim, VectorizedArrayType, is_face> *other);
* as FEValues, including matrix assembly.
*/
FEEvaluationAccess(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
const FEEvaluationData<dim, VectorizedArrayType, is_face> *other);
* as FEValues, including matrix assembly.
*/
FEEvaluationAccess(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
const FEEvaluationData<dim, VectorizedArrayType, is_face> *other);
* as FEValues, including matrix assembly.
*/
FEEvaluationAccess(
- const Mapping<1> & mapping,
+ const Mapping<1> &mapping,
const FiniteElement<1> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
const FEEvaluationData<1, VectorizedArrayType, is_face> *other);
* The rest of the arguments are the same as in the constructor above.
*/
FEEvaluation(const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- const std::pair<unsigned int, unsigned int> & range,
+ const std::pair<unsigned int, unsigned int> &range,
const unsigned int dof_no = 0,
const unsigned int quad_no = 0,
const unsigned int first_selected_component = 0);
* possibly within the element if the evaluate/integrate routines are
* combined inside user code (e.g. for computing cell matrices).
*/
- FEEvaluation(const Mapping<dim> & mapping,
+ FEEvaluation(const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component = 0);
* (i.e., an object of type MappingQ(1)) implicitly.
*/
FEEvaluation(const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component = 0);
* use the FEEvaluation object in %parallel to the given one because
* otherwise the intended sharing may create race conditions.
*/
- FEEvaluation(const FiniteElement<dim> & fe,
+ FEEvaluation(const FiniteElement<dim> &fe,
const FEEvaluationData<dim, VectorizedArrayType, false> &other,
const unsigned int first_selected_component = 0);
* useful information (unless these values have been set manually).
*/
void
- evaluate(const VectorizedArrayType * values_array,
+ evaluate(const VectorizedArrayType *values_array,
const EvaluationFlags::EvaluationFlags evaluation_flag);
/**
*/
template <typename VectorType>
void
- gather_evaluate(const VectorType & input_vector,
+ gather_evaluate(const VectorType &input_vector,
const EvaluationFlags::EvaluationFlags evaluation_flag);
/**
*/
void
integrate(const EvaluationFlags::EvaluationFlags integration_flag,
- VectorizedArrayType * values_array,
+ VectorizedArrayType *values_array,
const bool sum_into_values = false);
/**
template <typename VectorType>
void
integrate_scatter(const EvaluationFlags::EvaluationFlags integration_flag,
- VectorType & output_vector);
+ VectorType &output_vector);
/**
* Return an object that can be thought of as an array containing all indices
*/
FEFaceEvaluation(
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- const std::pair<unsigned int, unsigned int> & range,
+ const std::pair<unsigned int, unsigned int> &range,
const bool is_interior_face = true,
const unsigned int dof_no = 0,
const unsigned int quad_no = 0,
* been set manually).
*/
void
- evaluate(const VectorizedArrayType * values_array,
+ evaluate(const VectorizedArrayType *values_array,
const EvaluationFlags::EvaluationFlags evaluation_flag);
/**
*/
template <typename VectorType>
void
- gather_evaluate(const VectorType & input_vector,
+ gather_evaluate(const VectorType &input_vector,
const EvaluationFlags::EvaluationFlags evaluation_flag);
/**
*/
void
integrate(const EvaluationFlags::EvaluationFlags integration_flag,
- VectorizedArrayType * values_array);
+ VectorizedArrayType *values_array);
/**
* This function takes the values and/or gradients that are stored on
template <typename VectorType>
void
integrate_scatter(const EvaluationFlags::EvaluationFlags integration_flag,
- VectorType & output_vector);
+ VectorType &output_vector);
/**
* @deprecated Please use the integrate_scatter() function with the EvaluationFlags argument.
is_face,
VectorizedArrayType>::
FEEvaluationBase(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
const FEEvaluationData<dim, VectorizedArrayType, is_face> *other)
inline void
FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
read_write_operation(
- const VectorOperation & operation,
+ const VectorOperation &operation,
const std::array<VectorType *, n_components_> &src,
const std::array<
const std::vector<ArrayView<const typename VectorType::value_type>> *,
- n_components_> & src_sm,
+ n_components_> &src_sm,
const std::bitset<n_lanes> &mask,
const bool apply_constraints) const
{
inline void
FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
read_write_operation_global(
- const VectorOperation & operation,
+ const VectorOperation &operation,
const std::array<VectorType *, n_components_> &src) const
{
Assert(!local_dof_indices.empty(), ExcNotInitialized());
inline void
FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
read_write_operation_contiguous(
- const VectorOperation & operation,
+ const VectorOperation &operation,
const std::array<VectorType *, n_components_> &src,
const std::array<
const std::vector<ArrayView<const typename VectorType::value_type>> *,
- n_components_> & vectors_sm,
+ n_components_> &vectors_sm,
const std::bitset<n_lanes> &mask) const
{
// This functions processes the functions read_dof_values,
const unsigned int n_active_lanes = mask.count();
const internal::MatrixFreeFunctions::DoFInfo &dof_info = *this->dof_info;
- const std::vector<unsigned int> & dof_indices_cont =
+ const std::vector<unsigned int> &dof_indices_cont =
dof_info.dof_indices_contiguous[ind];
const std::size_t dofs_per_component = this->data->dofs_per_component_on_cell;
std::enable_if_t<has_shared_vector_data<VectorType>, VectorType> * =
nullptr>
const std::vector<ArrayView<const typename VectorType::value_type>> *
- get_shared_vector_data(VectorType * vec,
+ get_shared_vector_data(VectorType *vec,
const bool is_valid_mode_for_sm,
const unsigned int active_fe_index,
const internal::MatrixFreeFunctions::DoFInfo *dof_info)
VectorType,
IsBlockVector<VectorType>::value>::BaseVectorType::value_type>> *,
n_components>>
- get_vector_data(VectorType & src,
+ get_vector_data(VectorType &src,
const unsigned int first_index,
const bool is_valid_mode_for_sm,
const unsigned int active_fe_index,
template <typename VectorType>
inline void
FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
- read_dof_values(const VectorType & src,
+ read_dof_values(const VectorType &src,
const unsigned int first_index,
const std::bitset<n_lanes> &mask)
{
template <typename VectorType>
inline void
FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
- read_dof_values_plain(const VectorType & src,
+ read_dof_values_plain(const VectorType &src,
const unsigned int first_index,
const std::bitset<n_lanes> &mask)
{
template <typename VectorType>
inline void
FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
- distribute_local_to_global(VectorType & dst,
+ distribute_local_to_global(VectorType &dst,
const unsigned int first_index,
const std::bitset<n_lanes> &mask) const
{
template <typename VectorType>
inline void
FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
- set_dof_values(VectorType & dst,
+ set_dof_values(VectorType &dst,
const unsigned int first_index,
const std::bitset<n_lanes> &mask) const
{
template <typename VectorType>
inline void
FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
- set_dof_values_plain(VectorType & dst,
+ set_dof_values_plain(VectorType &dst,
const unsigned int first_index,
const std::bitset<n_lanes> &mask) const
{
is_face,
VectorizedArrayType>::
FEEvaluationAccess(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
const FEEvaluationData<dim, VectorizedArrayType, is_face> *other)
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::
FEEvaluationAccess(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
const FEEvaluationData<dim, VectorizedArrayType, is_face> *other)
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>::
FEEvaluationAccess(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
const FEEvaluationData<dim, VectorizedArrayType, is_face> *other)
template <typename Number, bool is_face, typename VectorizedArrayType>
inline FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::
FEEvaluationAccess(
- const Mapping<1> & mapping,
+ const Mapping<1> &mapping,
const FiniteElement<1> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
const FEEvaluationData<1, VectorizedArrayType, is_face> *other)
Number,
VectorizedArrayType>::
FEEvaluation(const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- const std::pair<unsigned int, unsigned int> & range,
+ const std::pair<unsigned int, unsigned int> &range,
const unsigned int dof_no,
const unsigned int quad_no,
const unsigned int first_selected_component)
n_components_,
Number,
VectorizedArrayType>::
- FEEvaluation(const Mapping<dim> & mapping,
+ FEEvaluation(const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component)
: BaseClass(mapping,
Number,
VectorizedArrayType>::
FEEvaluation(const FiniteElement<dim> &fe,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component)
: BaseClass(StaticMappingQ1<dim>::mapping,
n_components_,
Number,
VectorizedArrayType>::
- FEEvaluation(const FiniteElement<dim> & fe,
+ FEEvaluation(const FiniteElement<dim> &fe,
const FEEvaluationData<dim, VectorizedArrayType, false> &other,
const unsigned int first_selected_component)
: BaseClass(other.mapped_geometry->get_fe_values().get_mapping(),
n_components_,
Number,
VectorizedArrayType>::
- evaluate(const VectorizedArrayType * values_array,
+ evaluate(const VectorizedArrayType *values_array,
const EvaluationFlags::EvaluationFlags evaluation_flag)
{
const bool hessians_on_general_cells =
return nullptr;
const unsigned int cell = fe_eval.get_cell_or_face_batch_id();
- const auto & dof_info = fe_eval.get_dof_info();
+ const auto &dof_info = fe_eval.get_dof_info();
// If the index storage is interleaved and contiguous and the vector
// storage has the correct alignment, we can directly pass the pointer
n_components_,
Number,
VectorizedArrayType>::
- gather_evaluate(const VectorType & input_vector,
+ gather_evaluate(const VectorType &input_vector,
const EvaluationFlags::EvaluationFlags evaluation_flag)
{
const VectorizedArrayType *src_ptr =
Number,
VectorizedArrayType>::
integrate(const EvaluationFlags::EvaluationFlags integration_flag,
- VectorizedArrayType * values_array,
+ VectorizedArrayType *values_array,
const bool sum_into_values_array)
{
# ifdef DEBUG
Number,
VectorizedArrayType>::
integrate_scatter(const EvaluationFlags::EvaluationFlags integration_flag,
- VectorType & destination)
+ VectorType &destination)
{
VectorizedArrayType *dst_ptr =
internal::check_vector_access_inplace<Number, VectorizedArrayType>(
VectorizedArrayType>::
FEFaceEvaluation(
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- const std::pair<unsigned int, unsigned int> & range,
+ const std::pair<unsigned int, unsigned int> &range,
const bool is_interior_face,
const unsigned int dof_no,
const unsigned int quad_no,
n_components_,
Number,
VectorizedArrayType>::
- evaluate(const VectorizedArrayType * values_array,
+ evaluate(const VectorizedArrayType *values_array,
const EvaluationFlags::EvaluationFlags evaluation_flag)
{
Assert((evaluation_flag &
Number,
VectorizedArrayType>::
integrate(const EvaluationFlags::EvaluationFlags integration_flag,
- VectorizedArrayType * values_array)
+ VectorizedArrayType *values_array)
{
Assert((integration_flag &
~(EvaluationFlags::values | EvaluationFlags::gradients |
n_components_,
Number,
VectorizedArrayType>::
- gather_evaluate(const VectorType & input_vector,
+ gather_evaluate(const VectorType &input_vector,
const EvaluationFlags::EvaluationFlags evaluation_flag)
{
Assert((evaluation_flag &
Number,
VectorizedArrayType>::
integrate_scatter(const EvaluationFlags::EvaluationFlags integration_flag,
- VectorType & destination)
+ VectorType &destination)
{
Assert((this->dof_access_index ==
internal::MatrixFreeFunctions::DoFInfo::dof_access_cell &&
*/
struct InitializationData
{
- const ShapeInfoType * shape_info;
- const DoFInfo * dof_info;
+ const ShapeInfoType *shape_info;
+ const DoFInfo *dof_info;
const MappingInfoStorageType *mapping_data;
unsigned int active_fe_index;
unsigned int active_quad_index;
FEEvaluationData(
const std::shared_ptr<
internal::MatrixFreeFunctions::MappingDataOnTheFly<dim, Number>>
- & mapping_data,
+ &mapping_data,
const unsigned int n_fe_components,
const unsigned int first_selected_component);
inline FEEvaluationData<dim, Number, is_face>::FEEvaluationData(
const std::shared_ptr<
internal::MatrixFreeFunctions::MappingDataOnTheFly<dim, Number>>
- & mapped_geometry,
+ &mapped_geometry,
const unsigned int n_fe_components,
const unsigned int first_selected_component)
: data(nullptr)
typename FU>
inline void
process_cell_or_face_data(const std::array<unsigned int, N> indices,
- VectorOfArrayType & array,
- ArrayType & out,
- const FU & fu)
+ VectorOfArrayType &array,
+ ArrayType &out,
+ const FU &fu)
{
for (unsigned int i = 0; i < N; ++i)
if (indices[i] != numbers::invalid_unsigned_int)
template <std::size_t N, typename VectorOfArrayType, typename ArrayType>
inline void
set_valid_element_to_array(const std::array<unsigned int, N> indices,
- const VectorOfArrayType & array,
- ArrayType & out)
+ const VectorOfArrayType &array,
+ ArrayType &out)
{
AssertDimension(indices.size(), out.size());
AssertDimension(indices.size(), array[0].size());
}
static void
- write_value(VectorizedArrayType & vector_entry,
+ write_value(VectorizedArrayType &vector_entry,
const unsigned int component,
const vectorized_value_type &result)
{
static void
set_gradient(const interface_vectorized_gradient_type &value,
const unsigned int vector_lane,
- gradient_type & result)
+ gradient_type &result)
{
for (unsigned int i = 0; i < n_components; ++i)
for (unsigned int d = 0; d < dim; ++d)
static void
get_gradient(interface_vectorized_gradient_type &value,
const unsigned int vector_lane,
- const gradient_type & result)
+ const gradient_type &result)
{
for (unsigned int i = 0; i < n_components; ++i)
for (unsigned int d = 0; d < dim; ++d)
static void
set_value(const vectorized_value_type &value,
const unsigned int vector_lane,
- scalar_value_type & result)
+ scalar_value_type &result)
{
for (unsigned int i = 0; i < n_components; ++i)
result[i] = value[i][vector_lane];
}
static void
- get_value(vectorized_value_type & value,
+ get_value(vectorized_value_type &value,
const unsigned int vector_lane,
const scalar_value_type &result)
{
}
static void
- access(value_type & value,
+ access(value_type &value,
const unsigned int vector_lane,
const unsigned int component,
const ScalarNumber &shape_value)
}
static ScalarNumber
- access(const value_type & value,
+ access(const value_type &value,
const unsigned int vector_lane,
const unsigned int component)
{
}
static void
- access(gradient_type & value,
+ access(gradient_type &value,
const unsigned int vector_lane,
const unsigned int component,
const Tensor<1, dim, ScalarNumber> &shape_gradient)
static void
set_gradient(const vectorized_gradient_type &value,
const unsigned int vector_lane,
- scalar_gradient_type & result)
+ scalar_gradient_type &result)
{
for (unsigned int d = 0; d < dim; ++d)
result[d] = value[d][vector_lane];
}
static void
- get_gradient(vectorized_gradient_type & value,
+ get_gradient(vectorized_gradient_type &value,
const unsigned int vector_lane,
const scalar_gradient_type &result)
{
static void
set_value(const vectorized_value_type &value,
const unsigned int vector_lane,
- scalar_value_type & result)
+ scalar_value_type &result)
{
result = value[vector_lane];
}
}
static void
- get_value(vectorized_value_type & value,
+ get_value(vectorized_value_type &value,
const unsigned int vector_lane,
const scalar_value_type &result)
{
}
static void
- access(value_type & value,
+ access(value_type &value,
const unsigned int vector_lane,
const unsigned int,
const ScalarNumber &shape_value)
}
static ScalarNumber
- access(const value_type & value,
+ access(const value_type &value,
const unsigned int vector_lane,
const unsigned int)
{
}
static void
- access(gradient_type & value,
+ access(gradient_type &value,
const unsigned int vector_lane,
const unsigned int,
const scalar_gradient_type &shape_gradient)
}
static void
- write_value(VectorizedArrayType & vector_entry,
+ write_value(VectorizedArrayType &vector_entry,
const unsigned int component,
const vectorized_value_type &result)
{
static void
set_gradient(const interface_vectorized_gradient_type &value,
const unsigned int vector_lane,
- gradient_type & result)
+ gradient_type &result)
{
for (unsigned int i = 0; i < dim; ++i)
for (unsigned int d = 0; d < dim; ++d)
static void
get_gradient(interface_vectorized_gradient_type &value,
const unsigned int vector_lane,
- const gradient_type & result)
+ const gradient_type &result)
{
for (unsigned int i = 0; i < dim; ++i)
for (unsigned int d = 0; d < dim; ++d)
static void
set_value(const vectorized_value_type &value,
const unsigned int vector_lane,
- scalar_value_type & result)
+ scalar_value_type &result)
{
for (unsigned int i = 0; i < dim; ++i)
result[i] = value[i][vector_lane];
}
static void
- get_value(vectorized_value_type & value,
+ get_value(vectorized_value_type &value,
const unsigned int vector_lane,
const scalar_value_type &result)
{
}
static void
- access(value_type & value,
+ access(value_type &value,
const unsigned int vector_lane,
const unsigned int component,
const ScalarNumber &shape_value)
}
static ScalarNumber
- access(const value_type & value,
+ access(const value_type &value,
const unsigned int vector_lane,
const unsigned int component)
{
}
static void
- access(gradient_type & value,
+ access(gradient_type &value,
const unsigned int vector_lane,
const unsigned int component,
const Tensor<1, dim, ScalarNumber> &shape_gradient)
static void
set_gradient(const vectorized_gradient_type &value,
const unsigned int vector_lane,
- scalar_gradient_type & result)
+ scalar_gradient_type &result)
{
result[0] = value[0][vector_lane];
}
}
static void
- get_gradient(vectorized_gradient_type & value,
+ get_gradient(vectorized_gradient_type &value,
const unsigned int vector_lane,
const scalar_gradient_type &result)
{
static void
set_value(const vectorized_value_type &value,
const unsigned int vector_lane,
- scalar_value_type & result)
+ scalar_value_type &result)
{
result = value[vector_lane];
}
}
static void
- get_value(vectorized_value_type & value,
+ get_value(vectorized_value_type &value,
const unsigned int vector_lane,
const scalar_value_type &result)
{
}
static void
- access(value_type & value,
+ access(value_type &value,
const unsigned int vector_lane,
const unsigned int,
const ScalarNumber &shape_value)
}
static ScalarNumber
- access(const value_type & value,
+ access(const value_type &value,
const unsigned int vector_lane,
const unsigned int)
{
}
static void
- access(gradient_type & value,
+ access(gradient_type &value,
const unsigned int vector_lane,
const unsigned int,
const scalar_gradient_type &shape_gradient)
* objects, this parameter allows to select a range of `n_components`
* components starting from this parameter.
*/
- FEPointEvaluation(const Mapping<dim> & mapping,
+ FEPointEvaluation(const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
const UpdateFlags update_flags,
const unsigned int first_selected_component = 0);
*/
FEPointEvaluation(
NonMatching::MappingInfo<dim, spacedim, Number> &mapping_info,
- const FiniteElement<dim> & fe,
+ const FiniteElement<dim> &fe,
const unsigned int first_selected_component = 0);
/**
* evaluated at the points.
*/
void
- evaluate(const ArrayView<const ScalarNumber> & solution_values,
+ evaluate(const ArrayView<const ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &evaluation_flags);
/**
*
*/
void
- integrate(const ArrayView<ScalarNumber> & solution_values,
+ integrate(const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags);
/**
*
*/
void
- test_and_sum(const ArrayView<ScalarNumber> & solution_values,
+ test_and_sum(const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags);
/**
*/
void
prepare_evaluate_fast(
- const ArrayView<const ScalarNumber> & solution_values,
+ const ArrayView<const ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &evaluation_flags);
/**
const EvaluationFlags::EvaluationFlags &evaluation_flags,
const unsigned int n_shapes,
const unsigned int qb,
- vectorized_value_type & value,
- interface_vectorized_gradient_type & gradient);
+ vectorized_value_type &value,
+ interface_vectorized_gradient_type &gradient);
/**
* Fast path of the evaluate function.
*/
void
- evaluate_fast(const ArrayView<const ScalarNumber> & solution_values,
+ evaluate_fast(const ArrayView<const ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &evaluation_flags);
/**
* Slow path of the evaluate function using FEValues.
*/
void
- evaluate_slow(const ArrayView<const ScalarNumber> & solution_values,
+ evaluate_slow(const ArrayView<const ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &evaluation_flags);
/**
*/
void
compute_integrate_fast(
- const EvaluationFlags::EvaluationFlags & integration_flags,
+ const EvaluationFlags::EvaluationFlags &integration_flags,
const unsigned int n_shapes,
const unsigned int qb,
- const vectorized_value_type & value,
+ const vectorized_value_type &value,
const interface_vectorized_gradient_type &gradient);
/**
*/
void
finish_integrate_fast(
- const ArrayView<ScalarNumber> & solution_values,
+ const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags);
/**
*/
template <bool do_JxW>
void
- integrate_fast(const ArrayView<ScalarNumber> & solution_values,
+ integrate_fast(const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags);
/**
*/
template <bool do_JxW>
void
- integrate_slow(const ArrayView<ScalarNumber> & solution_values,
+ integrate_slow(const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags);
/**
*/
template <bool do_JxW>
void
- do_integrate(const ArrayView<ScalarNumber> & solution_values,
+ do_integrate(const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags);
/**
template <int n_components_, int dim, int spacedim, typename Number>
FEPointEvaluation<n_components_, dim, spacedim, Number>::FEPointEvaluation(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
const UpdateFlags update_flags,
const unsigned int first_selected_component)
template <int n_components_, int dim, int spacedim, typename Number>
FEPointEvaluation<n_components_, dim, spacedim, Number>::FEPointEvaluation(
NonMatching::MappingInfo<dim, spacedim, Number> &mapping_info,
- const FiniteElement<dim> & fe,
+ const FiniteElement<dim> &fe,
const unsigned int first_selected_component)
: n_q_points(numbers::invalid_unsigned_int)
, n_q_points_scalar(numbers::invalid_unsigned_int)
void
FEPointEvaluation<n_components_, dim, spacedim, Number>::reinit(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const ArrayView<const Point<dim>> & unit_points)
+ const ArrayView<const Point<dim>> &unit_points)
{
// reinit is only allowed for mapping computation on the fly
AssertThrow(mapping_info_on_the_fly.get() != nullptr, ExcNotImplemented());
template <int n_components_, int dim, int spacedim, typename Number>
inline void
FEPointEvaluation<n_components_, dim, spacedim, Number>::prepare_evaluate_fast(
- const ArrayView<const ScalarNumber> & solution_values,
+ const ArrayView<const ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &evaluation_flags)
{
if (use_face_path)
const EvaluationFlags::EvaluationFlags &evaluation_flags,
const unsigned int n_shapes,
const unsigned int qb,
- vectorized_value_type & value,
- interface_vectorized_gradient_type & gradient)
+ vectorized_value_type &value,
+ interface_vectorized_gradient_type &gradient)
{
if (use_face_path)
{
template <int n_components_, int dim, int spacedim, typename Number>
inline void
FEPointEvaluation<n_components_, dim, spacedim, Number>::evaluate_fast(
- const ArrayView<const ScalarNumber> & solution_values,
+ const ArrayView<const ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &evaluation_flags)
{
prepare_evaluate_fast(solution_values, evaluation_flags);
template <int n_components_, int dim, int spacedim, typename Number>
inline void
FEPointEvaluation<n_components_, dim, spacedim, Number>::evaluate_slow(
- const ArrayView<const ScalarNumber> & solution_values,
+ const ArrayView<const ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &evaluation_flags)
{
// slow path with FEValues
template <int n_components_, int dim, int spacedim, typename Number>
void
FEPointEvaluation<n_components_, dim, spacedim, Number>::evaluate(
- const ArrayView<const ScalarNumber> & solution_values,
+ const ArrayView<const ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &evaluation_flags)
{
if (!is_reinitialized)
template <int n_components_, int dim, int spacedim, typename Number>
inline void
FEPointEvaluation<n_components_, dim, spacedim, Number>::compute_integrate_fast(
- const EvaluationFlags::EvaluationFlags & integration_flags,
+ const EvaluationFlags::EvaluationFlags &integration_flags,
const unsigned int n_shapes,
const unsigned int qb,
- const vectorized_value_type & value,
+ const vectorized_value_type &value,
const interface_vectorized_gradient_type &gradient)
{
if (use_face_path)
template <int n_components_, int dim, int spacedim, typename Number>
inline void
FEPointEvaluation<n_components_, dim, spacedim, Number>::finish_integrate_fast(
- const ArrayView<ScalarNumber> & solution_values,
+ const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags)
{
std::fill(solution_values.begin(), solution_values.end(), ScalarNumber());
if (use_face_path)
{
const unsigned int size_input = 2 * dofs_per_component_face;
- ScalarNumber * input = scratch_data_scalar.begin();
- ScalarNumber * output = input + size_input;
+ ScalarNumber *input = scratch_data_scalar.begin();
+ ScalarNumber *output = input + size_input;
for (unsigned int i = 0; i < 2 * dofs_per_component_face; ++i)
{
template <bool do_JxW>
inline void
FEPointEvaluation<n_components_, dim, spacedim, Number>::integrate_fast(
- const ArrayView<ScalarNumber> & solution_values,
+ const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags)
{
// fast path with tensor product integration
template <bool do_JxW>
inline void
FEPointEvaluation<n_components_, dim, spacedim, Number>::integrate_slow(
- const ArrayView<ScalarNumber> & solution_values,
+ const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags)
{
// slow path with FEValues
template <bool do_JxW>
void
FEPointEvaluation<n_components_, dim, spacedim, Number>::do_integrate(
- const ArrayView<ScalarNumber> & solution_values,
+ const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags)
{
if (!is_reinitialized)
template <int n_components_, int dim, int spacedim, typename Number>
void
FEPointEvaluation<n_components_, dim, spacedim, Number>::integrate(
- const ArrayView<ScalarNumber> & solution_values,
+ const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags)
{
do_integrate<true>(solution_values, integration_flags);
template <int n_components_, int dim, int spacedim, typename Number>
void
FEPointEvaluation<n_components_, dim, spacedim, Number>::test_and_sum(
- const ArrayView<ScalarNumber> & solution_values,
+ const ArrayView<ScalarNumber> &solution_values,
const EvaluationFlags::EvaluationFlags &integration_flags)
{
do_integrate<false>(solution_values, integration_flags);
template <int n_components_, int dim, int spacedim, typename Number>
inline void
FEPointEvaluation<n_components_, dim, spacedim, Number>::submit_value(
- const value_type & value,
+ const value_type &value,
const unsigned int point_index)
{
AssertIndexRange(point_index, n_q_points);
template <typename CellIterator>
bool
setup_constraints(
- const CellIterator & cell,
+ const CellIterator &cell,
const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner,
const std::vector<std::vector<unsigned int>> &lexicographic_mapping,
- std::vector<types::global_dof_index> & dof_indices,
- const ArrayView<ConstraintKinds> & mask) const;
+ std::vector<types::global_dof_index> &dof_indices,
+ const ArrayView<ConstraintKinds> &mask) const;
/**
* Compute the supported components of all entries of the given
template <typename CellIterator>
void
update_dof_indices(
- const CellIterator & cell,
+ const CellIterator &cell,
const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner,
const std::vector<std::vector<unsigned int>> &lexicographic_mapping,
- const std::vector<std::vector<bool>> & component_mask,
- const ConstraintKinds & refinement_configuration,
- std::vector<types::global_dof_index> & dof_indices) const;
+ const std::vector<std::vector<bool>> &component_mask,
+ const ConstraintKinds &refinement_configuration,
+ std::vector<types::global_dof_index> &dof_indices) const;
private:
/**
template <typename CellIterator>
inline void
HangingNodes<dim>::update_dof_indices(
- const CellIterator & cell,
+ const CellIterator &cell,
const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner,
const std::vector<std::vector<unsigned int>> &lexicographic_mapping,
- const std::vector<std::vector<bool>> & supported_components,
- const ConstraintKinds & refinement_configuration,
- std::vector<types::global_dof_index> & dof_indices) const
+ const std::vector<std::vector<bool>> &supported_components,
+ const ConstraintKinds &refinement_configuration,
+ std::vector<types::global_dof_index> &dof_indices) const
{
if (std::find(supported_components[cell->active_fe_index()].begin(),
supported_components[cell->active_fe_index()].end(),
template <typename CellIterator>
inline bool
HangingNodes<dim>::setup_constraints(
- const CellIterator & cell,
+ const CellIterator &cell,
const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner,
const std::vector<std::vector<unsigned int>> &lexicographic_mapping,
- std::vector<types::global_dof_index> & dof_indices,
- const ArrayView<ConstraintKinds> & masks) const
+ std::vector<types::global_dof_index> &dof_indices,
+ const ArrayView<ConstraintKinds> &masks) const
{
// 1) check if finite elements support fast hanging-node algorithm
const auto supported_components = compute_supported_components(
* element, FE_Nothing, is used internally for the underlying FEValues
* object.
*/
- MappingDataOnTheFly(const Mapping<dim> & mapping,
+ MappingDataOnTheFly(const Mapping<dim> &mapping,
const Quadrature<1> &quadrature,
const UpdateFlags update_flags);
template <int dim, typename Number>
inline MappingDataOnTheFly<dim, Number>::MappingDataOnTheFly(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const Quadrature<1> &quadrature,
const UpdateFlags update_flags)
: fe_values(std::make_unique<dealii::FEValues<dim>>(
*/
void
initialize(
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
- const FaceInfo<VectorizedArrayType::size()> & face_info,
+ const FaceInfo<VectorizedArrayType::size()> &face_info,
const std::vector<unsigned int> &active_fe_index,
const std::shared_ptr<dealii::hp::MappingCollection<dim>> &mapping,
- const std::vector<dealii::hp::QCollection<dim>> & quad,
+ const std::vector<dealii::hp::QCollection<dim>> &quad,
const UpdateFlags update_flags_cells,
const UpdateFlags update_flags_boundary_faces,
const UpdateFlags update_flags_inner_faces,
*/
void
update_mapping(
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
- const FaceInfo<VectorizedArrayType::size()> & face_info,
+ const FaceInfo<VectorizedArrayType::size()> &face_info,
const std::vector<unsigned int> &active_fe_index,
const std::shared_ptr<dealii::hp::MappingCollection<dim>> &mapping);
*/
template <typename StreamType>
void
- print_memory_consumption(StreamType & out,
+ print_memory_consumption(StreamType &out,
const TaskInfo &task_info) const;
/**
*/
void
compute_mapping_q(
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
- const FaceInfo<VectorizedArrayType::size()> & face_info);
+ const FaceInfo<VectorizedArrayType::size()> &face_info);
/**
* Computes the information in the given cells, called within
*/
void
initialize_cells(
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
- const std::vector<unsigned int> & active_fe_index,
+ const std::vector<unsigned int> &active_fe_index,
const dealii::hp::MappingCollection<dim> &mapping);
/**
*/
void
initialize_faces(
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
const std::vector<FaceToCellTopology<VectorizedArrayType::size()>>
- & faces,
- const std::vector<unsigned int> & active_fe_index,
+ &faces,
+ const std::vector<unsigned int> &active_fe_index,
const dealii::hp::MappingCollection<dim> &mapping);
/**
*/
void
initialize_faces_by_cells(
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
- const FaceInfo<VectorizedArrayType::size()> & face_info,
- const dealii::hp::MappingCollection<dim> & mapping);
+ const FaceInfo<VectorizedArrayType::size()> &face_info,
+ const dealii::hp::MappingCollection<dim> &mapping);
};
template <int dim, typename Number, typename VectorizedArrayType>
void
MappingInfo<dim, Number, VectorizedArrayType>::initialize(
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
- const FaceInfo<VectorizedArrayType::size()> & face_info,
- const std::vector<unsigned int> & active_fe_index,
+ const FaceInfo<VectorizedArrayType::size()> &face_info,
+ const std::vector<unsigned int> &active_fe_index,
const std::shared_ptr<dealii::hp::MappingCollection<dim>> &mapping,
- const std::vector<dealii::hp::QCollection<dim>> & quad,
+ const std::vector<dealii::hp::QCollection<dim>> &quad,
const UpdateFlags update_flags_cells,
const UpdateFlags update_flags_boundary_faces,
const UpdateFlags update_flags_inner_faces,
template <int dim, typename Number, typename VectorizedArrayType>
void
MappingInfo<dim, Number, VectorizedArrayType>::update_mapping(
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
- const FaceInfo<VectorizedArrayType::size()> & face_info,
- const std::vector<unsigned int> & active_fe_index,
+ const FaceInfo<VectorizedArrayType::size()> &face_info,
+ const std::vector<unsigned int> &active_fe_index,
const std::shared_ptr<dealii::hp::MappingCollection<dim>> &mapping)
{
AssertDimension(cells.size() / VectorizedArrayType::size(),
inline DEAL_II_ALWAYS_INLINE void
store_vectorized_array(const VectorizedArrayType1 value,
const unsigned int offset,
- VectorizedArrayType2 & result)
+ VectorizedArrayType2 &result)
{
static_assert(VectorizedArrayType2::size() >=
VectorizedArrayType1::size(),
*/
template <int dim, typename VectorizedArrayType>
void
- evaluate_on_cell(const dealii::Triangulation<dim> & tria,
+ evaluate_on_cell(const dealii::Triangulation<dim> &tria,
const std::pair<unsigned int, unsigned int> *cells,
const unsigned int my_q,
- GeometryType & cell_t_prev,
- GeometryType * cell_t,
- dealii::FEValues<dim, dim> & fe_val,
+ GeometryType &cell_t_prev,
+ GeometryType *cell_t,
+ dealii::FEValues<dim, dim> &fe_val,
LocalData<dim,
typename VectorizedArrayType::value_type,
- VectorizedArrayType> & cell_data)
+ VectorizedArrayType> &cell_data)
{
const unsigned int n_q_points = fe_val.n_quadrature_points;
const UpdateFlags update_flags = fe_val.get_update_flags();
void
initialize_cell_range(
const std::pair<unsigned int, unsigned int> cell_range,
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
- const std::vector<unsigned int> & active_fe_index,
- const dealii::hp::MappingCollection<dim> & mapping,
+ const std::vector<unsigned int> &active_fe_index,
+ const dealii::hp::MappingCollection<dim> &mapping,
MappingInfo<dim, Number, VectorizedArrayType> &mapping_info,
std::pair<
std::vector<MappingInfoStorage<dim, dim, VectorizedArrayType>>,
template <typename CONTAINER>
void
- merge_compressed_data(const CONTAINER & source,
- CONTAINER & destination,
+ merge_compressed_data(const CONTAINER &source,
+ CONTAINER &destination,
std::vector<unsigned int> &indices)
{
indices.resize(source.size());
copy_data(
const unsigned int first_cell,
const std::array<std::size_t, 2> &data_shift,
- const std::vector<unsigned int> & indices_compressed,
- const std::vector<GeometryType> & cell_type,
+ const std::vector<unsigned int> &indices_compressed,
+ const std::vector<GeometryType> &cell_type,
MappingInfoStorage<structdim, dim, VectorizedArrayType>
&data_cells_local,
MappingInfoStorage<structdim, dim, VectorizedArrayType> &data_cells)
mapping_q_query_fe_values(
const unsigned int begin_cell,
const unsigned int end_cell,
- const MappingQ<dim> & mapping_q,
- const dealii::Triangulation<dim> & tria,
+ const MappingQ<dim> &mapping_q,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cell_array,
const double jacobian_size,
std::vector<GeometryType> &preliminary_cell_type,
- AlignedVector<double> & plain_quadrature_points,
+ AlignedVector<double> &plain_quadrature_points,
AlignedVector<std::array<Tensor<2, dim>, dim + 1>>
&jacobians_on_stencil)
{
mapping_q_find_compression(
const double jacobian_size,
const AlignedVector<std::array<Tensor<2, dim>, dim + 1>>
- & jacobians_on_stencil,
+ &jacobians_on_stencil,
const unsigned int n_mapping_points,
const AlignedVector<double> &plain_quadrature_points,
- std::vector<GeometryType> & preliminary_cell_type)
+ std::vector<GeometryType> &preliminary_cell_type)
{
std::vector<unsigned int> cell_data_index(jacobians_on_stencil.size());
mapping_q_compute_range(
const unsigned int begin_cell,
const unsigned int end_cell,
- const std::vector<GeometryType> & cell_type,
- const std::vector<bool> & process_cell,
+ const std::vector<GeometryType> &cell_type,
+ const std::vector<bool> &process_cell,
const UpdateFlags update_flags_cells,
- const AlignedVector<double> & plain_quadrature_points,
+ const AlignedVector<double> &plain_quadrature_points,
const ShapeInfo<VectorizedDouble> &shape_info,
MappingInfoStorage<dim, dim, VectorizedArrayType> &my_data)
{
template <int dim, typename Number, typename VectorizedArrayType>
void
MappingInfo<dim, Number, VectorizedArrayType>::initialize_cells(
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
- const std::vector<unsigned int> & active_fe_index,
- const dealii::hp::MappingCollection<dim> & mapping)
+ const std::vector<unsigned int> &active_fe_index,
+ const dealii::hp::MappingCollection<dim> &mapping)
{
const unsigned int n_cells = cells.size();
const unsigned int n_lanes = VectorizedArrayType::size();
void
initialize_face_range(
const std::pair<unsigned int, unsigned int> face_range,
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
const std::vector<FaceToCellTopology<VectorizedArrayType::size()>>
- & faces,
- const std::vector<unsigned int> & active_fe_index,
- const dealii::hp::MappingCollection<dim> & mapping_in,
+ &faces,
+ const std::vector<unsigned int> &active_fe_index,
+ const dealii::hp::MappingCollection<dim> &mapping_in,
MappingInfo<dim, Number, VectorizedArrayType> &mapping_info,
std::pair<
std::vector<MappingInfoStorage<dim - 1, dim, VectorizedArrayType>>,
const unsigned int last_face,
const std::vector<GeometryType> &face_type,
const std::vector<FaceToCellTopology<VectorizedArrayType::size()>>
- & faces,
+ &faces,
MappingInfoStorage<dim - 1, dim, VectorizedArrayType> &data_faces)
{
for (unsigned int face = first_face; face < last_face; ++face)
const unsigned int begin_face,
const unsigned int end_face,
const std::vector<FaceToCellTopology<VectorizedArrayType::size()>>
- & faces,
- const std::vector<GeometryType> & face_type,
- const std::vector<bool> & process_face,
+ &faces,
+ const std::vector<GeometryType> &face_type,
+ const std::vector<bool> &process_face,
const UpdateFlags update_flags_faces,
- const AlignedVector<double> & plain_quadrature_points,
+ const AlignedVector<double> &plain_quadrature_points,
const ShapeInfo<VectorizedDouble> &shape_info,
MappingInfoStorage<dim - 1, dim, VectorizedArrayType> &my_data)
{
template <int dim, typename Number, typename VectorizedArrayType>
void
MappingInfo<dim, Number, VectorizedArrayType>::initialize_faces(
- const dealii::Triangulation<dim> & tria,
- const std::vector<std::pair<unsigned int, unsigned int>> & cells,
+ const dealii::Triangulation<dim> &tria,
+ const std::vector<std::pair<unsigned int, unsigned int>> &cells,
const std::vector<FaceToCellTopology<VectorizedArrayType::size()>> &faces,
- const std::vector<unsigned int> & active_fe_index,
+ const std::vector<unsigned int> &active_fe_index,
const dealii::hp::MappingCollection<dim> &mapping)
{
face_type.resize(faces.size(), general);
template <int dim, typename Number, typename VectorizedArrayType>
void
MappingInfo<dim, Number, VectorizedArrayType>::compute_mapping_q(
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cell_array,
- const FaceInfo<VectorizedArrayType::size()> & face_info)
+ const FaceInfo<VectorizedArrayType::size()> &face_info)
{
// step 1: extract quadrature point data with the data appropriate for
// MappingQ
template <int dim, typename Number, typename VectorizedArrayType>
void
MappingInfo<dim, Number, VectorizedArrayType>::initialize_faces_by_cells(
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
- const FaceInfo<VectorizedArrayType::size()> & face_info,
- const dealii::hp::MappingCollection<dim> & mapping_in)
+ const FaceInfo<VectorizedArrayType::size()> &face_info,
+ const dealii::hp::MappingCollection<dim> &mapping_in)
{
if (update_flags_faces_by_cells == update_default)
return;
template <typename StreamType>
void
MappingInfo<dim, Number, VectorizedArrayType>::print_memory_consumption(
- StreamType & out,
+ StreamType &out,
const TaskInfo &task_info) const
{
out << " Cell types: ";
*/
template <typename StreamType>
void
- print_memory_consumption(StreamType & out,
+ print_memory_consumption(StreamType &out,
const TaskInfo &task_info) const;
/**
template <typename StreamType>
void
MappingInfoStorage<structdim, spacedim, Number>::print_memory_consumption(
- StreamType & out,
+ StreamType &out,
const TaskInfo &task_info) const
{
// print_memory_statistics involves global communication, so we can
*/
template <typename QuadratureType, typename number2, typename MappingType>
void
- reinit(const MappingType & mapping,
- const DoFHandler<dim> & dof_handler,
+ reinit(const MappingType &mapping,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<number2> &constraint,
- const QuadratureType & quad,
- const AdditionalData & additional_data = AdditionalData());
+ const QuadratureType &quad,
+ const AdditionalData &additional_data = AdditionalData());
/**
* Extracts the information needed to perform loops over cells. The
*/
template <typename QuadratureType, typename number2, typename MappingType>
void
- reinit(const MappingType & mapping,
- const std::vector<const DoFHandler<dim> *> & dof_handler,
+ reinit(const MappingType &mapping,
+ const std::vector<const DoFHandler<dim> *> &dof_handler,
const std::vector<const AffineConstraints<number2> *> &constraint,
- const std::vector<QuadratureType> & quad,
+ const std::vector<QuadratureType> &quad,
const AdditionalData &additional_data = AdditionalData());
/**
*/
template <typename QuadratureType, typename number2, typename MappingType>
void
- reinit(const MappingType & mapping,
- const std::vector<const DoFHandler<dim> *> & dof_handler,
+ reinit(const MappingType &mapping,
+ const std::vector<const DoFHandler<dim> *> &dof_handler,
const std::vector<const AffineConstraints<number2> *> &constraint,
- const QuadratureType & quad,
+ const QuadratureType &quad,
const AdditionalData &additional_data = AdditionalData());
/**
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &)> &cell_operation,
- OutVector & dst,
- const InVector & src,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector = false) const;
/**
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &) const,
- const CLASS * owning_class,
- OutVector & dst,
+ const CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const bool zero_dst_vector = false) const;
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &),
- CLASS * owning_class,
- OutVector & dst,
+ CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const bool zero_dst_vector = false) const;
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &) const,
- const CLASS * owning_class,
- OutVector & dst,
+ const CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post = 0) const;
/**
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &),
- CLASS * owning_class,
- OutVector & dst,
+ CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post = 0) const;
/**
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &)> &cell_operation,
- OutVector & dst,
- const InVector & src,
+ OutVector &dst,
+ const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post = 0) const;
/**
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &)> &boundary_operation,
- OutVector & dst,
- const InVector & src,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector = false,
const DataAccessOnFaces dst_vector_face_access =
DataAccessOnFaces::unspecified,
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &) const,
- const CLASS * owning_class,
- OutVector & dst,
- const InVector & src,
+ const CLASS *owning_class,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector = false,
const DataAccessOnFaces dst_vector_face_access =
DataAccessOnFaces::unspecified,
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &),
- CLASS * owning_class,
- OutVector & dst,
- const InVector & src,
+ CLASS *owning_class,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector = false,
const DataAccessOnFaces dst_vector_face_access =
DataAccessOnFaces::unspecified,
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &) const,
- const CLASS * owning_class,
- OutVector & dst,
+ const CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post = 0,
const DataAccessOnFaces dst_vector_face_access =
DataAccessOnFaces::unspecified,
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &),
- const CLASS * owning_class,
- OutVector & dst,
+ const CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post = 0,
const DataAccessOnFaces dst_vector_face_access =
DataAccessOnFaces::unspecified,
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &)> &boundary_operation,
- OutVector & dst,
- const InVector & src,
+ OutVector &dst,
+ const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post = 0,
const DataAccessOnFaces dst_vector_face_access =
DataAccessOnFaces::unspecified,
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &) const,
- const CLASS * owning_class,
- OutVector & dst,
- const InVector & src,
+ const CLASS *owning_class,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector = false,
const DataAccessOnFaces src_vector_face_access =
DataAccessOnFaces::unspecified) const;
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &),
- CLASS * owning_class,
- OutVector & dst,
- const InVector & src,
+ CLASS *owning_class,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector = false,
const DataAccessOnFaces src_vector_face_access =
DataAccessOnFaces::unspecified) const;
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &)>
- & cell_operation,
- OutVector & dst,
- const InVector & src,
+ &cell_operation,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector = false,
const DataAccessOnFaces src_vector_face_access =
DataAccessOnFaces::unspecified) const;
*/
template <typename VectorType>
void
- initialize_dof_vector(VectorType & vec,
+ initialize_dof_vector(VectorType &vec,
const unsigned int dof_handler_index = 0) const;
/**
template <typename number2, int q_dim>
void
internal_reinit(
- const std::shared_ptr<hp::MappingCollection<dim>> & mapping,
- const std::vector<const DoFHandler<dim, dim> *> & dof_handlers,
+ const std::shared_ptr<hp::MappingCollection<dim>> &mapping,
+ const std::vector<const DoFHandler<dim, dim> *> &dof_handlers,
const std::vector<const AffineConstraints<number2> *> &constraint,
- const std::vector<IndexSet> & locally_owned_set,
- const std::vector<hp::QCollection<q_dim>> & quad,
- const AdditionalData & additional_data);
+ const std::vector<IndexSet> &locally_owned_set,
+ const std::vector<hp::QCollection<q_dim>> &quad,
+ const AdditionalData &additional_data);
/**
* Initializes the fields in DoFInfo together with the constraint pool that
void
initialize_indices(
const std::vector<const AffineConstraints<number2> *> &constraint,
- const std::vector<IndexSet> & locally_owned_set,
- const AdditionalData & additional_data);
+ const std::vector<IndexSet> &locally_owned_set,
+ const AdditionalData &additional_data);
/**
* Initializes the DoFHandlers based on a DoFHandler<dim> argument.
void
initialize_dof_handlers(
const std::vector<const DoFHandler<dim, dim> *> &dof_handlers,
- const AdditionalData & additional_data);
+ const AdditionalData &additional_data);
/**
* Pointers to the DoFHandlers underlying the current problem.
template <typename VectorType>
inline void
MatrixFree<dim, Number, VectorizedArrayType>::initialize_dof_vector(
- VectorType & vec,
+ VectorType &vec,
const unsigned int comp) const
{
static_assert(IsBlockVector<VectorType>::value == false,
template <typename QuadratureType, typename number2, typename MappingType>
void
MatrixFree<dim, Number, VectorizedArrayType>::reinit(
- const MappingType & mapping,
- const DoFHandler<dim> & dof_handler,
+ const MappingType &mapping,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<number2> &constraints_in,
- const QuadratureType & quad,
+ const QuadratureType &quad,
const typename MatrixFree<dim, Number, VectorizedArrayType>::AdditionalData
&additional_data)
{
template <typename QuadratureType, typename number2, typename MappingType>
void
MatrixFree<dim, Number, VectorizedArrayType>::reinit(
- const MappingType & mapping,
- const std::vector<const DoFHandler<dim> *> & dof_handler,
+ const MappingType &mapping,
+ const std::vector<const DoFHandler<dim> *> &dof_handler,
const std::vector<const AffineConstraints<number2> *> &constraint,
- const QuadratureType & quad,
+ const QuadratureType &quad,
const typename MatrixFree<dim, Number, VectorizedArrayType>::AdditionalData
&additional_data)
{
template <typename QuadratureType, typename number2, typename MappingType>
void
MatrixFree<dim, Number, VectorizedArrayType>::reinit(
- const MappingType & mapping,
- const std::vector<const DoFHandler<dim> *> & dof_handler,
+ const MappingType &mapping,
+ const std::vector<const DoFHandler<dim> *> &dof_handler,
const std::vector<const AffineConstraints<number2> *> &constraint,
- const std::vector<QuadratureType> & quad,
+ const std::vector<QuadratureType> &quad,
const typename MatrixFree<dim, Number, VectorizedArrayType>::AdditionalData
&additional_data)
{
VectorType> * = nullptr>
void
update_ghost_values_start(const unsigned int component_in_block_vector,
- const VectorType & vec)
+ const VectorType &vec)
{
(void)component_in_block_vector;
const bool ghosts_set = vec.has_ghost_elements();
VectorType> * = nullptr>
void
update_ghost_values_start(const unsigned int component_in_block_vector,
- const VectorType & vec)
+ const VectorType &vec)
{
(void)component_in_block_vector;
const bool ghosts_set = vec.has_ghost_elements();
VectorType> * = nullptr>
void
update_ghost_values_start(const unsigned int component_in_block_vector,
- const VectorType & vec)
+ const VectorType &vec)
{
static_assert(std::is_same_v<Number, typename VectorType::value_type>,
"Type mismatch between VectorType and VectorDataExchange");
VectorType> * = nullptr>
void
update_ghost_values_finish(const unsigned int component_in_block_vector,
- const VectorType & vec)
+ const VectorType &vec)
{
(void)component_in_block_vector;
vec.update_ghost_values_finish();
VectorType> * = nullptr>
void
update_ghost_values_finish(const unsigned int component_in_block_vector,
- const VectorType & vec)
+ const VectorType &vec)
{
static_assert(std::is_same_v<Number, typename VectorType::value_type>,
"Type mismatch between VectorType and VectorDataExchange");
VectorType> * = nullptr>
void
compress_start(const unsigned int component_in_block_vector,
- VectorType & vec)
+ VectorType &vec)
{
(void)component_in_block_vector;
Assert(vec.has_ghost_elements() == false, ExcNotImplemented());
VectorType> * = nullptr>
void
compress_start(const unsigned int component_in_block_vector,
- VectorType & vec)
+ VectorType &vec)
{
(void)component_in_block_vector;
Assert(vec.has_ghost_elements() == false, ExcNotImplemented());
VectorType> * = nullptr>
void
compress_start(const unsigned int component_in_block_vector,
- VectorType & vec)
+ VectorType &vec)
{
static_assert(std::is_same_v<Number, typename VectorType::value_type>,
"Type mismatch between VectorType and VectorDataExchange");
VectorType> * = nullptr>
void
compress_finish(const unsigned int component_in_block_vector,
- VectorType & vec)
+ VectorType &vec)
{
(void)component_in_block_vector;
vec.compress_finish(VectorOperation::add);
VectorType> * = nullptr>
void
compress_finish(const unsigned int component_in_block_vector,
- VectorType & vec)
+ VectorType &vec)
{
static_assert(std::is_same_v<Number, typename VectorType::value_type>,
"Type mismatch between VectorType and VectorDataExchange");
*/
template <typename VectorType,
std::enable_if_t<!has_exchange_on_subset<VectorType>, VectorType>
- * = nullptr,
+ * = nullptr,
typename VectorType::value_type * = nullptr>
void
zero_vector_region(const unsigned int range_index, VectorType &vec) const
* = nullptr>
void
update_ghost_values_start(
- const VectorStruct & vec,
+ const VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger,
const unsigned int channel = 0)
{
* = nullptr>
void
update_ghost_values_start(
- const VectorStruct & vec,
+ const VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger,
const unsigned int channel = 0)
{
typename VectorizedArrayType>
inline void
update_ghost_values_start(
- const std::vector<VectorStruct> & vec,
+ const std::vector<VectorStruct> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
unsigned int component_index = 0;
typename VectorizedArrayType>
inline void
update_ghost_values_start(
- const std::vector<VectorStruct *> & vec,
+ const std::vector<VectorStruct *> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
unsigned int component_index = 0;
* = nullptr>
void
update_ghost_values_finish(
- const VectorStruct & vec,
+ const VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger,
const unsigned int channel = 0)
{
* = nullptr>
void
update_ghost_values_finish(
- const VectorStruct & vec,
+ const VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger,
const unsigned int channel = 0)
{
typename VectorizedArrayType>
inline void
update_ghost_values_finish(
- const std::vector<VectorStruct> & vec,
+ const std::vector<VectorStruct> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
unsigned int component_index = 0;
typename VectorizedArrayType>
inline void
update_ghost_values_finish(
- const std::vector<VectorStruct *> & vec,
+ const std::vector<VectorStruct *> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
unsigned int component_index = 0;
* = nullptr>
inline void
compress_start(
- VectorStruct & vec,
+ VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger,
const unsigned int channel = 0)
{
* = nullptr>
inline void
compress_start(
- VectorStruct & vec,
+ VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger,
const unsigned int channel = 0)
{
typename VectorizedArrayType>
inline void
compress_start(
- std::vector<VectorStruct> & vec,
+ std::vector<VectorStruct> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
unsigned int component_index = 0;
typename VectorizedArrayType>
inline void
compress_start(
- std::vector<VectorStruct *> & vec,
+ std::vector<VectorStruct *> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
unsigned int component_index = 0;
* = nullptr>
inline void
compress_finish(
- VectorStruct & vec,
+ VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger,
const unsigned int channel = 0)
{
* = nullptr>
inline void
compress_finish(
- VectorStruct & vec,
+ VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger,
const unsigned int channel = 0)
{
typename VectorizedArrayType>
inline void
compress_finish(
- std::vector<VectorStruct> & vec,
+ std::vector<VectorStruct> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
unsigned int component_index = 0;
typename VectorizedArrayType>
inline void
compress_finish(
- std::vector<VectorStruct *> & vec,
+ std::vector<VectorStruct *> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
unsigned int component_index = 0;
* = nullptr>
inline void
reset_ghost_values(
- const VectorStruct & vec,
+ const VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
// return immediately if there is nothing to do.
* = nullptr>
inline void
reset_ghost_values(
- const VectorStruct & vec,
+ const VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
exchanger.reset_ghost_values(vec);
typename VectorizedArrayType>
inline void
reset_ghost_values(
- const std::vector<VectorStruct> & vec,
+ const std::vector<VectorStruct> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
// return immediately if there is nothing to do.
typename VectorizedArrayType>
inline void
reset_ghost_values(
- const std::vector<VectorStruct *> & vec,
+ const std::vector<VectorStruct *> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
// return immediately if there is nothing to do.
inline void
zero_vector_region(
const unsigned int range_index,
- VectorStruct & vec,
+ VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
for (unsigned int i = 0; i < vec.n_blocks(); ++i)
inline void
zero_vector_region(
const unsigned int range_index,
- VectorStruct & vec,
+ VectorStruct &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
exchanger.zero_vector_region(range_index, vec);
inline void
zero_vector_region(
const unsigned int range_index,
- std::vector<VectorStruct> & vec,
+ std::vector<VectorStruct> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
for (unsigned int comp = 0; comp < vec.size(); ++comp)
inline void
zero_vector_region(
const unsigned int range_index,
- std::vector<VectorStruct *> & vec,
+ std::vector<VectorStruct *> &vec,
VectorDataExchange<dim, Number, VectorizedArrayType> &exchanger)
{
for (unsigned int comp = 0; comp < vec.size(); ++comp)
template <typename Number>
inline void
apply_operation_to_constrained_dofs(
- const std::vector<unsigned int> & constrained_dofs,
+ const std::vector<unsigned int> &constrained_dofs,
const LinearAlgebra::distributed::Vector<Number> &src,
- LinearAlgebra::distributed::Vector<Number> & dst)
+ LinearAlgebra::distributed::Vector<Number> &dst)
{
for (const unsigned int i : constrained_dofs)
dst.local_element(i) = src.local_element(i);
function_type;
// constructor, binds all the arguments to this class
- MFWorker(const MF & matrix_free,
- const InVector & src,
- OutVector & dst,
+ MFWorker(const MF &matrix_free,
+ const InVector &src,
+ OutVector &dst,
const bool zero_dst_vector_setting,
- const Container & container,
+ const Container &container,
function_type cell_function,
function_type face_function,
function_type boundary_function,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop = {},
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop = {},
+ &operation_after_loop = {},
const unsigned int dof_handler_index_pre_post = 0)
: matrix_free(matrix_free)
, container(const_cast<Container &>(container))
private:
void
- process_range(const function_type & fu,
+ process_range(const function_type &fu,
const std::vector<unsigned int> &ptr,
const std::vector<unsigned int> &data,
const unsigned int range_index)
}
private:
- const MF & matrix_free;
- Container & container;
+ const MF &matrix_free;
+ Container &container;
function_type cell_function;
function_type face_function;
function_type boundary_function;
const InVector &src;
- OutVector & dst;
+ OutVector &dst;
VectorDataExchange<MF::dimension,
typename MF::value_type,
typename MF::vectorized_value_type>
{}
void
- cell_integrator(const MF & mf,
- OutVector & dst,
- const InVector & src,
+ cell_integrator(const MF &mf,
+ OutVector &dst,
+ const InVector &src,
const std::pair<unsigned int, unsigned int> &range) const
{
if (cell)
}
void
- face_integrator(const MF & mf,
- OutVector & dst,
- const InVector & src,
+ face_integrator(const MF &mf,
+ OutVector &dst,
+ const InVector &src,
const std::pair<unsigned int, unsigned int> &range) const
{
if (face)
void
boundary_integrator(
- const MF & mf,
- OutVector & dst,
- const InVector & src,
+ const MF &mf,
+ OutVector &dst,
+ const InVector &src,
const std::pair<unsigned int, unsigned int> &range) const
{
if (boundary)
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &)>
- & cell_operation,
- OutVector & dst,
+ &cell_operation,
+ OutVector &dst,
const InVector &src,
const bool zero_dst_vector) const
{
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &)>
- & cell_operation,
- OutVector & dst,
+ &cell_operation,
+ OutVector &dst,
const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post) const
{
using Wrapper =
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &)>
- & boundary_operation,
- OutVector & dst,
- const InVector & src,
+ &boundary_operation,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector,
const DataAccessOnFaces dst_vector_face_access,
const DataAccessOnFaces src_vector_face_access) const
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &) const,
- const CLASS * owning_class,
- OutVector & dst,
+ const CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const bool zero_dst_vector) const
{
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &) const,
- const CLASS * owning_class,
- OutVector & dst,
+ const CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post) const
{
internal::MFWorker<MatrixFree<dim, Number, VectorizedArrayType>,
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &) const,
- const CLASS * owning_class,
- OutVector & dst,
- const InVector & src,
+ const CLASS *owning_class,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector,
const DataAccessOnFaces dst_vector_face_access,
const DataAccessOnFaces src_vector_face_access) const
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &),
- CLASS * owning_class,
- OutVector & dst,
+ CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const bool zero_dst_vector) const
{
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &),
- CLASS * owning_class,
- OutVector & dst,
+ CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post) const
{
internal::MFWorker<MatrixFree<dim, Number, VectorizedArrayType>,
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &),
- CLASS * owning_class,
- OutVector & dst,
- const InVector & src,
+ CLASS *owning_class,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector,
const DataAccessOnFaces dst_vector_face_access,
const DataAccessOnFaces src_vector_face_access) const
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &)>
- & boundary_operation,
- OutVector & dst,
+ &boundary_operation,
+ OutVector &dst,
const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post,
const DataAccessOnFaces dst_vector_face_access,
const DataAccessOnFaces src_vector_face_access) const
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &) const,
- const CLASS * owning_class,
- OutVector & dst,
+ const CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post,
const DataAccessOnFaces dst_vector_face_access,
const DataAccessOnFaces src_vector_face_access) const
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &),
- const CLASS * owning_class,
- OutVector & dst,
+ const CLASS *owning_class,
+ OutVector &dst,
const InVector &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
const std::function<void(const unsigned int, const unsigned int)>
- & operation_after_loop,
+ &operation_after_loop,
const unsigned int dof_handler_index_pre_post,
const DataAccessOnFaces dst_vector_face_access,
const DataAccessOnFaces src_vector_face_access) const
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &) const,
- const CLASS * owning_class,
- OutVector & dst,
- const InVector & src,
+ const CLASS *owning_class,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector,
const DataAccessOnFaces src_vector_face_access) const
{
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &),
- CLASS * owning_class,
- OutVector & dst,
- const InVector & src,
+ CLASS *owning_class,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector,
const DataAccessOnFaces src_vector_face_access) const
{
OutVector &,
const InVector &,
const std::pair<unsigned int, unsigned int> &)>
- & cell_operation,
- OutVector & dst,
- const InVector & src,
+ &cell_operation,
+ OutVector &dst,
+ const InVector &src,
const bool zero_dst_vector,
const DataAccessOnFaces src_vector_face_access) const
{
template <int vectorization_width>
bool
operator()(const internal::MatrixFreeFunctions::FaceToCellTopology<
- vectorization_width> & face,
+ vectorization_width> &face,
const std::array<unsigned int, 2> &fe_index)
{
const unsigned int face_type = face.face_type;
template <int vectorization_width>
bool
operator()(const internal::MatrixFreeFunctions::FaceToCellTopology<
- vectorization_width> & face,
+ vectorization_width> &face,
const std::array<unsigned int, 3> &fe_index)
{
const unsigned int face_type = face.face_type;
template <typename Number>
void
store_affine_constraints(
- const dealii::AffineConstraints<Number> * affine_constraints,
+ const dealii::AffineConstraints<Number> *affine_constraints,
SmartPointer<const dealii::AffineConstraints<Number>> &stored_constraints)
{
stored_constraints = affine_constraints;
template <typename number2, int q_dim>
void
MatrixFree<dim, Number, VectorizedArrayType>::internal_reinit(
- const std::shared_ptr<hp::MappingCollection<dim>> & mapping,
- const std::vector<const DoFHandler<dim, dim> *> & dof_handler,
+ const std::shared_ptr<hp::MappingCollection<dim>> &mapping,
+ const std::vector<const DoFHandler<dim, dim> *> &dof_handler,
const std::vector<const AffineConstraints<number2> *> &constraints,
- const std::vector<IndexSet> & locally_owned_dofs,
- const std::vector<hp::QCollection<q_dim>> & quad,
+ const std::vector<IndexSet> &locally_owned_dofs,
+ const std::vector<hp::QCollection<q_dim>> &quad,
const typename MatrixFree<dim, Number, VectorizedArrayType>::AdditionalData
&additional_data)
{
// steps through all children and adds the active cells recursively
template <typename InIterator>
void
- resolve_cell(const InIterator & cell,
+ resolve_cell(const InIterator &cell,
std::vector<std::pair<unsigned int, unsigned int>> &cell_its)
{
if (cell->has_children())
void
MatrixFree<dim, Number, VectorizedArrayType>::initialize_dof_handlers(
const std::vector<const DoFHandler<dim, dim> *> &dof_handler_in,
- const AdditionalData & additional_data)
+ const AdditionalData &additional_data)
{
cell_level_index.clear();
dof_handlers.resize(dof_handler_in.size());
fill_connectivity_subrange(
const unsigned int begin,
const unsigned int end,
- const dealii::Triangulation<dim> & tria,
+ const dealii::Triangulation<dim> &tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cell_level_index,
const tbb::concurrent_unordered_map<std::pair<unsigned int, unsigned int>,
unsigned int
unsigned_int_pair_hash
# endif
> &map,
- DynamicSparsityPattern & connectivity_direct)
+ DynamicSparsityPattern &connectivity_direct)
{
std::vector<types::global_dof_index> new_indices;
for (unsigned int cell = begin; cell < end; ++cell)
const unsigned int begin,
const unsigned int end,
const DynamicSparsityPattern &connectivity_direct,
- DynamicSparsityPattern & connectivity)
+ DynamicSparsityPattern &connectivity)
{
std::vector<types::global_dof_index> new_indices;
for (unsigned int block = begin; block < end; ++block)
std::vector<bool>
compute_dof_info(
const std::vector<const dealii::AffineConstraints<number> *> &constraint,
- const std::vector<IndexSet> & locally_owned_dofs,
+ const std::vector<IndexSet> &locally_owned_dofs,
const std::vector<SmartPointer<const DoFHandler<dim>>> &dof_handlers,
const Table<2, MatrixFreeFunctions::ShapeInfo<double>> &shape_infos,
const unsigned int cell_level_index_end_local,
const bool do_face_integrals,
const bool build_inner_faces,
const bool overlap_communication_computation,
- MatrixFreeFunctions::TaskInfo & task_info,
+ MatrixFreeFunctions::TaskInfo &task_info,
std::vector<std::pair<unsigned int, unsigned int>> &cell_level_index,
- std::vector<MatrixFreeFunctions::DoFInfo> & dof_info,
- MatrixFreeFunctions::FaceSetup<dim> & face_setup,
- MatrixFreeFunctions::ConstraintValues<double> & constraint_values,
+ std::vector<MatrixFreeFunctions::DoFInfo> &dof_info,
+ MatrixFreeFunctions::FaceSetup<dim> &face_setup,
+ MatrixFreeFunctions::ConstraintValues<double> &constraint_values,
const bool use_vector_data_exchanger_full)
{
if (do_face_integrals)
&tria, cell_level_index[c].first, cell_level_index[c].second);
Assert(cell->level() > 0, ExcInternalError());
const auto parent = cell->parent();
- auto & entry = cell_parents[parent->level()][parent->index()];
+ auto &entry = cell_parents[parent->level()][parent->index()];
entry.second[entry.first++] = c;
}
unsigned int position = 0;
void
MatrixFree<dim, Number, VectorizedArrayType>::initialize_indices(
const std::vector<const AffineConstraints<number2> *> &constraint,
- const std::vector<IndexSet> & locally_owned_dofs,
- const AdditionalData & additional_data)
+ const std::vector<IndexSet> &locally_owned_dofs,
+ const AdditionalData &additional_data)
{
// insert possible ghost cells and construct face topology
const bool do_face_integrals =
void
initialize(std::shared_ptr<
const MatrixFree<dim, value_type, VectorizedArrayType>> data,
- const MGConstrainedDoFs & mg_constrained_dofs,
+ const MGConstrainedDoFs &mg_constrained_dofs,
const unsigned int level,
const std::vector<unsigned int> &selected_row_blocks =
std::vector<unsigned int>());
const MatrixFree<dim, value_type, VectorizedArrayType>> data_,
const std::vector<MGConstrainedDoFs> &mg_constrained_dofs,
const unsigned int level,
- const std::vector<unsigned int> & selected_row_blocks =
+ const std::vector<unsigned int> &selected_row_blocks =
std::vector<unsigned int>());
/**
* multiplies the result with the relaxation factor <tt>omega</tt>.
*/
void
- precondition_Jacobi(VectorType & dst,
+ precondition_Jacobi(VectorType &dst,
const VectorType &src,
const value_type omega) const;
* Tvmult_add (@p transpose = true).
*/
void
- mult_add(VectorType & dst,
+ mult_add(VectorType &dst,
const VectorType &src,
const bool transpose) const;
void
apply(const AlignedVector<VectorizedArrayType> &inverse_coefficient,
const unsigned int n_actual_components,
- const VectorizedArrayType * in_array,
- VectorizedArrayType * out_array) const;
+ const VectorizedArrayType *in_array,
+ VectorizedArrayType *out_array) const;
/**
* Applies the inverse @ref GlossMassMatrix "mass matrix" operation on an input array, using the
*/
void
apply(const VectorizedArrayType *in_array,
- VectorizedArrayType * out_array) const;
+ VectorizedArrayType *out_array) const;
/**
* This operation applies the inverse @ref GlossMassMatrix "mass matrix"
*/
void
apply(const AlignedVector<Tensor<2, n_components, VectorizedArrayType>>
- & inverse_dyadic_coefficients,
+ &inverse_dyadic_coefficients,
const VectorizedArrayType *in_array,
- VectorizedArrayType * out_array) const;
+ VectorizedArrayType *out_array) const;
/**
* This operation performs a projection from the data given in quadrature
void
local_apply_cell(
const MatrixFree<dim, value_type, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
/**
* A shared pointer to a diagonal matrix that stores the
void
local_apply_cell(
const MatrixFree<dim, value_type, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
/**
* Apply diagonal part of the Laplace operator on a cell.
void
local_diagonal_cell(
const MatrixFree<dim, value_type, VectorizedArrayType> &data,
- VectorType & dst,
+ VectorType &dst,
const VectorType &,
const std::pair<unsigned int, unsigned int> &cell_range) const;
n_components,
Number,
VectorizedArrayType>::apply(const VectorizedArrayType *in_array,
- VectorizedArrayType * out_array) const
+ VectorizedArrayType *out_array) const
{
if (fe_degree > -1)
internal::CellwiseInverseMassMatrixImplBasic<dim, VectorizedArrayType>::
VectorizedArrayType>::
apply(const AlignedVector<VectorizedArrayType> &inverse_coefficients,
const unsigned int n_actual_components,
- const VectorizedArrayType * in_array,
- VectorizedArrayType * out_array) const
+ const VectorizedArrayType *in_array,
+ VectorizedArrayType *out_array) const
{
if (fe_degree > -1)
internal::CellwiseInverseMassMatrixImplFlexible<
Number,
VectorizedArrayType>::
apply(const AlignedVector<Tensor<2, n_components, VectorizedArrayType>>
- & inverse_dyadic_coefficients,
+ &inverse_dyadic_coefficients,
const VectorizedArrayType *in_array,
- VectorizedArrayType * out_array) const
+ VectorizedArrayType *out_array) const
{
const unsigned int unrolled_size =
inverse_dyadic_coefficients.size() * (n_components * n_components);
VectorizedArrayType>::
transform_from_q_points_to_basis(const unsigned int n_actual_components,
const VectorizedArrayType *in_array,
- VectorizedArrayType * out_array) const
+ VectorizedArrayType *out_array) const
{
const auto n_q_points_1d = fe_eval.get_shape_info().data[0].n_q_points_1d;
Base<dim, VectorType, VectorizedArrayType>::initialize(
std::shared_ptr<const MatrixFree<dim, value_type, VectorizedArrayType>>
data_,
- const MGConstrainedDoFs & mg_constrained_dofs,
+ const MGConstrainedDoFs &mg_constrained_dofs,
const unsigned int level,
const std::vector<unsigned int> &given_row_selection)
{
data_,
const std::vector<MGConstrainedDoFs> &mg_constrained_dofs,
const unsigned int level,
- const std::vector<unsigned int> & given_row_selection)
+ const std::vector<unsigned int> &given_row_selection)
{
AssertThrow(level != numbers::invalid_unsigned_int,
ExcMessage("level is not set"));
template <int dim, typename VectorType, typename VectorizedArrayType>
void
- Base<dim, VectorType, VectorizedArrayType>::vmult(VectorType & dst,
+ Base<dim, VectorType, VectorizedArrayType>::vmult(VectorType &dst,
const VectorType &src) const
{
using Number =
template <int dim, typename VectorType, typename VectorizedArrayType>
void
Base<dim, VectorType, VectorizedArrayType>::vmult_add(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
mult_add(dst, src, false);
template <int dim, typename VectorType, typename VectorizedArrayType>
void
Base<dim, VectorType, VectorizedArrayType>::Tvmult_add(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
mult_add(dst, src, true);
template <int dim, typename VectorType, typename VectorizedArrayType>
void
Base<dim, VectorType, VectorizedArrayType>::preprocess_constraints(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
using Number =
template <int dim, typename VectorType, typename VectorizedArrayType>
void
Base<dim, VectorType, VectorizedArrayType>::mult_add(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src,
const bool transpose) const
{
template <int dim, typename VectorType, typename VectorizedArrayType>
void
Base<dim, VectorType, VectorizedArrayType>::postprocess_constraints(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
for (unsigned int j = 0; j < BlockHelper::n_blocks(dst); ++j)
template <int dim, typename VectorType, typename VectorizedArrayType>
void
Base<dim, VectorType, VectorizedArrayType>::vmult_interface_down(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
using Number =
template <int dim, typename VectorType, typename VectorizedArrayType>
void
Base<dim, VectorType, VectorizedArrayType>::vmult_interface_up(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
using Number =
template <int dim, typename VectorType, typename VectorizedArrayType>
void
Base<dim, VectorType, VectorizedArrayType>::Tvmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
using Number =
template <int dim, typename VectorType, typename VectorizedArrayType>
void
Base<dim, VectorType, VectorizedArrayType>::Tapply_add(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
apply_add(dst, src);
template <int dim, typename VectorType, typename VectorizedArrayType>
void
Base<dim, VectorType, VectorizedArrayType>::precondition_Jacobi(
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const typename Base<dim, VectorType, VectorizedArrayType>::value_type omega)
const
{
template <typename OperatorType>
template <typename VectorType>
void
- MGInterfaceOperator<OperatorType>::vmult(VectorType & dst,
+ MGInterfaceOperator<OperatorType>::vmult(VectorType &dst,
const VectorType &src) const
{
#ifndef DEAL_II_MSVC
template <typename OperatorType>
template <typename VectorType>
void
- MGInterfaceOperator<OperatorType>::Tvmult(VectorType & dst,
+ MGInterfaceOperator<OperatorType>::Tvmult(VectorType &dst,
const VectorType &src) const
{
#ifndef DEAL_II_MSVC
n_q_points_1d,
n_components,
VectorType,
- VectorizedArrayType>::apply_add(VectorType & dst,
+ VectorizedArrayType>::apply_add(VectorType &dst,
const VectorType &src) const
{
Base<dim, VectorType, VectorizedArrayType>::data->cell_loop(
const MatrixFree<
dim,
typename Base<dim, VectorType, VectorizedArrayType>::value_type,
- VectorizedArrayType> & data,
- VectorType & dst,
- const VectorType & src,
+ VectorizedArrayType> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using Number =
n_q_points_1d,
n_components,
VectorType,
- VectorizedArrayType>::apply_add(VectorType & dst,
+ VectorizedArrayType>::apply_add(VectorType &dst,
const VectorType &src) const
{
Base<dim, VectorType, VectorizedArrayType>::data->cell_loop(
const MatrixFree<
dim,
typename Base<dim, VectorType, VectorizedArrayType>::value_type,
- VectorizedArrayType> & data,
- VectorType & dst,
- const VectorType & src,
+ VectorizedArrayType> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using Number =
dim,
typename Base<dim, VectorType, VectorizedArrayType>::value_type,
VectorizedArrayType> &data,
- VectorType & dst,
+ VectorType &dst,
const VectorType &,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
template <int dim, int spacedim>
void
evaluate_shape_functions(const FiniteElement<dim, spacedim> &fe,
- const Quadrature<1> & quad,
+ const Quadrature<1> &quad,
const std::vector<unsigned int> &lexicographic,
const unsigned int direction);
void
evaluate_collocation_space(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<1> & quad,
- const std::vector<unsigned int> & lexicographic);
+ const Quadrature<1> &quad,
+ const std::vector<unsigned int> &lexicographic);
/**
* Check whether we have symmetries in the shape values. In that case,
* Constructor that initializes the data fields using the reinit method.
*/
template <int dim, int spacedim, int dim_q>
- ShapeInfo(const Quadrature<dim_q> & quad,
+ ShapeInfo(const Quadrature<dim_q> &quad,
const FiniteElement<dim, spacedim> &fe,
const unsigned int base_element = 0);
*/
template <int dim, int spacedim, int dim_q>
void
- reinit(const Quadrature<dim_q> & quad,
+ reinit(const Quadrature<dim_q> &quad,
const FiniteElement<dim, spacedim> &fe_dim,
const unsigned int base_element = 0);
const FiniteElement<dim, dim> &fe_in,
const FiniteElement<dim, dim> &fe,
const unsigned int base_element_number,
- ElementType & element_type,
- std::vector<unsigned int> & scalar_lexicographic,
- std::vector<unsigned int> & lexicographic_numbering)
+ ElementType &element_type,
+ std::vector<unsigned int> &scalar_lexicographic,
+ std::vector<unsigned int> &lexicographic_numbering)
{
element_type = tensor_general;
template <typename Number>
template <int dim, int spacedim, int dim_q>
inline ShapeInfo<Number>::ShapeInfo(
- const Quadrature<dim_q> & quad,
+ const Quadrature<dim_q> &quad,
const FiniteElement<dim, spacedim> &fe_in,
const unsigned int base_element_number)
: element_type(tensor_general)
template <typename Number>
template <int dim, int spacedim, int dim_q>
void
- ShapeInfo<Number>::reinit(const Quadrature<dim_q> & quad_in,
+ ShapeInfo<Number>::reinit(const Quadrature<dim_q> &quad_in,
const FiniteElement<dim, spacedim> &fe_in,
const unsigned int base_element_number)
{
template <int dim, int spacedim>
Point<dim>
get_unit_point(const FiniteElement<dim, spacedim> &fe,
- const std::vector<unsigned int> & lexicographic)
+ const std::vector<unsigned int> &lexicographic)
{
Point<dim> unit_point;
// to evaluate 1d polynomials, evaluate along the line with the first
void
UnivariateShapeData<Number>::evaluate_shape_functions(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<1> & quad,
- const std::vector<unsigned int> & lexicographic,
+ const Quadrature<1> &quad,
+ const std::vector<unsigned int> &lexicographic,
const unsigned int direction)
{
const unsigned int n_dofs_1d =
void
UnivariateShapeData<Number>::evaluate_collocation_space(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<1> & quad,
- const std::vector<unsigned int> & lexicographic)
+ const Quadrature<1> &quad,
+ const std::vector<unsigned int> &lexicographic)
{
const unsigned int n_dofs_1d =
std::min(fe.n_dofs_per_cell(), fe_degree + 1);
const std::vector<unsigned int> &cell_vectorization_categories,
const bool cell_vectorization_categories_strict,
const std::vector<unsigned int> &parent_relation,
- std::vector<unsigned int> & renumbering,
- std::vector<unsigned char> & incompletely_filled_vectorization);
+ std::vector<unsigned int> &renumbering,
+ std::vector<unsigned char> &incompletely_filled_vectorization);
/**
* First step in the block creation for the task-parallel blocking setup.
void
initial_setup_blocks_tasks(
const std::vector<unsigned int> &boundary_cells,
- std::vector<unsigned int> & renumbering,
- std::vector<unsigned char> & incompletely_filled_vectorization);
+ std::vector<unsigned int> &renumbering,
+ std::vector<unsigned char> &incompletely_filled_vectorization);
/**
* This helper function determines a block size if the user decided not
*/
void
make_thread_graph_partition_color(
- DynamicSparsityPattern & connectivity,
- std::vector<unsigned int> & renumbering,
+ DynamicSparsityPattern &connectivity,
+ std::vector<unsigned int> &renumbering,
std::vector<unsigned char> &irregular_cells,
const bool hp_bool);
void
make_thread_graph_partition_partition(
const std::vector<unsigned int> &cell_active_fe_index,
- DynamicSparsityPattern & connectivity,
- std::vector<unsigned int> & renumbering,
- std::vector<unsigned char> & irregular_cells,
+ DynamicSparsityPattern &connectivity,
+ std::vector<unsigned int> &renumbering,
+ std::vector<unsigned char> &irregular_cells,
const bool hp_bool);
/**
*/
void
make_thread_graph(const std::vector<unsigned int> &cell_active_fe_index,
- DynamicSparsityPattern & connectivity,
- std::vector<unsigned int> & renumbering,
- std::vector<unsigned char> & irregular_cells,
+ DynamicSparsityPattern &connectivity,
+ std::vector<unsigned int> &renumbering,
+ std::vector<unsigned char> &irregular_cells,
const bool hp_bool);
/**
void
make_connectivity_cells_to_blocks(
const std::vector<unsigned char> &irregular_cells,
- const DynamicSparsityPattern & connectivity_cells,
- DynamicSparsityPattern & connectivity_blocks) const;
+ const DynamicSparsityPattern &connectivity_cells,
+ DynamicSparsityPattern &connectivity_blocks) const;
/**
* %Function to create coloring on the second layer within each
*/
void
make_coloring_within_partitions_pre_blocked(
- const DynamicSparsityPattern & connectivity,
+ const DynamicSparsityPattern &connectivity,
const unsigned int partition,
const std::vector<unsigned int> &cell_partition,
const std::vector<unsigned int> &partition_list,
const std::vector<unsigned int> &partition_size,
- std::vector<unsigned int> & partition_color_list);
+ std::vector<unsigned int> &partition_color_list);
/**
* %Function to create partitioning on the second layer within each
*/
void
make_partitioning_within_partitions_post_blocked(
- const DynamicSparsityPattern & connectivity,
+ const DynamicSparsityPattern &connectivity,
const std::vector<unsigned int> &cell_active_fe_index,
const unsigned int partition,
const unsigned int cluster_size,
const std::vector<unsigned int> &cell_partition,
const std::vector<unsigned int> &partition_list,
const std::vector<unsigned int> &partition_size,
- std::vector<unsigned int> & partition_partition_list,
- std::vector<unsigned char> & irregular_cells);
+ std::vector<unsigned int> &partition_partition_list,
+ std::vector<unsigned char> &irregular_cells);
/**
* This function creates partitions according to the provided connectivity
void
make_partitioning(const DynamicSparsityPattern &connectivity,
const unsigned int cluster_size,
- std::vector<unsigned int> & cell_partition,
- std::vector<unsigned int> & partition_list,
- std::vector<unsigned int> & partition_size,
- unsigned int & partition) const;
+ std::vector<unsigned int> &cell_partition,
+ std::vector<unsigned int> &partition_list,
+ std::vector<unsigned int> &partition_size,
+ unsigned int &partition) const;
/**
* Update fields of task info for task graph set up in
typename Number2>
std::enable_if_t<(variant == evaluate_general), void>
apply_matrix_vector_product(const Number2 *matrix,
- const Number * in,
- Number * out)
+ const Number *in,
+ Number *out)
{
// We can only statically assert that one argument is non-zero because
// face evaluation might instantiate some functions, so we need to use the
typename Number2>
std::enable_if_t<(variant == evaluate_general), void>
apply_matrix_vector_product(const Number2 *matrix,
- const Number * in,
- Number * out,
+ const Number *in,
+ Number *out,
const int n_rows,
const int n_columns,
const int stride_in,
typename Number2>
std::enable_if_t<(variant == evaluate_symmetric), void>
apply_matrix_vector_product(const Number2 *matrix,
- const Number * in,
- Number * out)
+ const Number *in,
+ Number *out)
{
// We can only statically assert that one argument is non-zero because
// face evaluation might instantiate some functions, so we need to use the
#endif
std::enable_if_t<(variant == evaluate_evenodd), void>
apply_matrix_vector_product(const Number2 *matrix,
- const Number * in,
- Number * out,
+ const Number *in,
+ Number *out,
int n_rows_runtime = 0,
int n_columns_runtime = 0,
int stride_in_runtime = 0,
typename Number2>
std::enable_if_t<(variant == evaluate_evenodd), void>
apply_matrix_vector_product(const Number2 *matrix,
- const Number * in,
- Number * out,
+ const Number *in,
+ Number *out,
int n_rows,
int n_columns,
int stride_in,
typename Number2>
std::enable_if_t<(variant == evaluate_symmetric_hierarchical), void>
apply_matrix_vector_product(const Number2 *matrix,
- const Number * in,
- Number * out)
+ const Number *in,
+ Number *out)
{
static_assert(n_rows > 0 && n_columns > 0,
"Specialization requires n_rows, n_columns > 0");
/**
* Constructor, taking the data from ShapeInfo via raw pointers
*/
- EvaluatorTensorProduct(const Number2 * shape_values,
- const Number2 * shape_gradients,
- const Number2 * shape_hessians,
+ EvaluatorTensorProduct(const Number2 *shape_values,
+ const Number2 *shape_gradients,
+ const Number2 *shape_hessians,
const unsigned int dummy1 = 0,
const unsigned int dummy2 = 0)
: shape_values(shape_values)
EvaluatorQuantity = EvaluatorQuantity::value>
static void
apply(const Number2 *DEAL_II_RESTRICT shape_data,
- const Number * in,
- Number * out);
+ const Number *in,
+ Number *out);
/**
* This function applies the tensor product operation to produce face values
inline void
EvaluatorTensorProduct<variant, dim, n_rows, n_columns, Number, Number2>::
apply(const Number2 *DEAL_II_RESTRICT shape_data,
- const Number * in,
- Number * out)
+ const Number *in,
+ Number *out)
{
static_assert(one_line == false || direction == dim - 1,
"Single-line evaluation only works for direction=dim-1.");
/**
* Constructor, taking the data from ShapeInfo
*/
- EvaluatorTensorProduct(const Number2 * shape_values,
- const Number2 * shape_gradients,
- const Number2 * shape_hessians,
+ EvaluatorTensorProduct(const Number2 *shape_values,
+ const Number2 *shape_gradients,
+ const Number2 *shape_hessians,
const unsigned int n_rows = 0,
const unsigned int n_columns = 0)
: shape_values(shape_values)
EvaluatorQuantity quantity = EvaluatorQuantity::value>
void
apply(const Number2 *DEAL_II_RESTRICT shape_data,
- const Number * in,
- Number * out) const;
+ const Number *in,
+ Number *out) const;
template <int face_direction,
bool contract_onto_face,
apply_face(const Number *DEAL_II_RESTRICT in,
Number *DEAL_II_RESTRICT out) const;
- const Number2 * shape_values;
- const Number2 * shape_gradients;
- const Number2 * shape_hessians;
+ const Number2 *shape_values;
+ const Number2 *shape_gradients;
+ const Number2 *shape_hessians;
const unsigned int n_rows;
const unsigned int n_columns;
};
inline void
EvaluatorTensorProduct<variant, dim, 0, 0, Number, Number2>::apply(
const Number2 *DEAL_II_RESTRICT shape_data,
- const Number * in,
- Number * out) const
+ const Number *in,
+ Number *out) const
{
static_assert(one_line == false || direction == dim - 1,
"Single-line evaluation only works for direction=dim-1.");
bool one_line = false>
static void
apply(const Number2 *DEAL_II_RESTRICT shape_data,
- const Number * in,
- Number * out);
+ const Number *in,
+ Number *out);
template <int face_direction,
bool contract_onto_face,
normal_dir,
Number,
Number2>::apply(const Number2 *DEAL_II_RESTRICT shape_data,
- const Number * in,
- Number * out)
+ const Number *in,
+ Number *out)
{
static_assert(one_line == false || direction == dim - 1,
"Single-line evaluation only works for direction=dim-1.");
template <int dim, typename Number>
inline void
compute_values_of_array(
- dealii::ndarray<Number, 2, dim> * shapes,
+ dealii::ndarray<Number, 2, dim> *shapes,
const std::vector<Polynomials::Polynomial<double>> &poly,
- const Point<dim, Number> & p,
+ const Point<dim, Number> &p,
const unsigned int derivative = 1)
{
const int n_shapes = poly.size();
#endif
std::array<typename ProductTypeNoPoint<Number, Number2>::type,
2 + n_values>
- do_interpolate_xy(const Number * values,
- const std::vector<unsigned int> & renumber,
+ do_interpolate_xy(const Number *values,
+ const std::vector<unsigned int> &renumber,
const dealii::ndarray<Number2, 2, dim> *shapes,
const int n_shapes_runtime,
- int & i)
+ int &i)
{
static_assert(0 <= dim && dim <= 3, "Only dim=0,1,2,3 implemented");
static_assert(1 <= n_values && n_values <= 2,
evaluate_tensor_product_value_and_gradient_shapes(
const dealii::ndarray<Number2, 2, dim> *shapes,
const int n_shapes,
- const Number * values,
- const std::vector<unsigned int> & renumber = {})
+ const Number *values,
+ const std::vector<unsigned int> &renumber = {})
{
static_assert(0 <= dim && dim <= 3, "Only dim=0,1,2,3 implemented");
static_assert(1 <= n_values && n_values <= 2,
dim + n_values>
evaluate_tensor_product_value_and_gradient_linear(
const unsigned int n_shapes,
- const Number * values,
- const Point<dim, Number2> & p,
+ const Number *values,
+ const Point<dim, Number2> &p,
const std::vector<unsigned int> &renumber = {})
{
static_assert(0 <= dim && dim <= 3, "Only dim=0,1,2,3 implemented");
Tensor<1, dim, typename ProductTypeNoPoint<Number, Number2>::type>>
evaluate_tensor_product_value_and_gradient(
const std::vector<Polynomials::Polynomial<double>> &poly,
- const std::vector<Number> & values,
- const Point<dim, Number2> & p,
+ const std::vector<Number> &values,
+ const Point<dim, Number2> &p,
const bool d_linear = false,
- const std::vector<unsigned int> & renumber = {})
+ const std::vector<unsigned int> &renumber = {})
{
using Number3 = typename ProductTypeNoPoint<Number, Number2>::type;
DEAL_II_ALWAYS_INLINE
#endif
typename ProductTypeNoPoint<Number, Number2>::type
- do_interpolate_xy_value(const Number * values,
- const std::vector<unsigned int> & renumber,
+ do_interpolate_xy_value(const Number *values,
+ const std::vector<unsigned int> &renumber,
const dealii::ndarray<Number2, 2, dim> *shapes,
const int n_shapes_runtime,
- int & i)
+ int &i)
{
const int n_shapes = length > 0 ? length : n_shapes_runtime;
using Number3 = typename ProductTypeNoPoint<Number, Number2>::type;
evaluate_tensor_product_value_shapes(
const dealii::ndarray<Number2, 2, dim> *shapes,
const int n_shapes,
- const Number * values,
- const std::vector<unsigned int> & renumber = {})
+ const Number *values,
+ const std::vector<unsigned int> &renumber = {})
{
static_assert(dim >= 0 && dim <= 3, "Only dim=0,1,2,3 implemented");
inline typename ProductTypeNoPoint<Number, Number2>::type
evaluate_tensor_product_value_linear(
const unsigned int n_shapes,
- const Number * values,
- const Point<dim, Number2> & p,
+ const Number *values,
+ const Point<dim, Number2> &p,
const std::vector<unsigned int> &renumber = {})
{
(void)n_shapes;
inline typename ProductTypeNoPoint<Number, Number2>::type
evaluate_tensor_product_value(
const std::vector<Polynomials::Polynomial<double>> &poly,
- const std::vector<Number> & values,
- const Point<dim, Number2> & p,
+ const std::vector<Number> &values,
+ const Point<dim, Number2> &p,
const bool d_linear = false,
- const std::vector<unsigned int> & renumber = {})
+ const std::vector<unsigned int> &renumber = {})
{
typename ProductTypeNoPoint<Number, Number2>::type result;
if (d_linear)
inline Tensor<1, 1, typename ProductTypeNoPoint<Number, Number2>::type>
evaluate_tensor_product_higher_derivatives(
const std::vector<Polynomials::Polynomial<double>> &poly,
- const std::vector<Number> & values,
- const Point<1, Number2> & p,
- const std::vector<unsigned int> & renumber = {})
+ const std::vector<Number> &values,
+ const Point<1, Number2> &p,
+ const std::vector<unsigned int> &renumber = {})
{
using Number3 = typename ProductTypeNoPoint<Number, Number2>::type;
typename ProductTypeNoPoint<Number, Number2>::type>
evaluate_tensor_product_higher_derivatives(
const std::vector<Polynomials::Polynomial<double>> &poly,
- const std::vector<Number> & values,
- const Point<2, Number2> & p,
- const std::vector<unsigned int> & renumber = {})
+ const std::vector<Number> &values,
+ const Point<2, Number2> &p,
+ const std::vector<unsigned int> &renumber = {})
{
using Number3 = typename ProductTypeNoPoint<Number, Number2>::type;
constexpr int dim = 2;
typename ProductTypeNoPoint<Number, Number2>::type>
evaluate_tensor_product_higher_derivatives(
const std::vector<Polynomials::Polynomial<double>> &poly,
- const std::vector<Number> & values,
- const Point<3, Number2> & p,
- const std::vector<unsigned int> & renumber = {})
+ const std::vector<Number> &values,
+ const Point<3, Number2> &p,
+ const std::vector<unsigned int> &renumber = {})
{
using Number3 = typename ProductTypeNoPoint<Number, Number2>::type;
constexpr int dim = 3;
SymmetricTensor<2, dim, typename ProductTypeNoPoint<Number, Number2>::type>
evaluate_tensor_product_hessian(
const std::vector<Polynomials::Polynomial<double>> &poly,
- const std::vector<Number> & values,
- const Point<dim, Number2> & p,
- const std::vector<unsigned int> & renumber = {})
+ const std::vector<Number> &values,
+ const Point<dim, Number2> &p,
+ const std::vector<unsigned int> &renumber = {})
{
static_assert(dim >= 1 && dim <= 3, "Only dim=1,2,3 implemented");
#endif
void
do_apply_test_functions_xy(
- Number2 * values,
- const dealii::ndarray<Number, 2, dim> * shapes,
+ Number2 *values,
+ const dealii::ndarray<Number, 2, dim> *shapes,
const std::array<Number2, 2 + n_values> &test_grads_value,
const int n_shapes_runtime,
- int & i)
+ int &i)
{
static_assert(0 <= dim && dim <= 3, "Only dim=0,1,2,3 implemented");
static_assert(1 <= n_values && n_values <= 2,
integrate_add_tensor_product_value_and_gradient_shapes(
const dealii::ndarray<Number, 2, dim> *shapes,
const int n_shapes,
- const Number2 * value,
- const Tensor<1, dim, Number2> & gradient,
- Number2 * values)
+ const Number2 *value,
+ const Tensor<1, dim, Number2> &gradient,
+ Number2 *values)
{
static_assert(0 <= dim && dim <= 3, "Only dim=0,1,2,3 implemented");
static_assert(1 <= n_values && n_values <= 2,
inline void
integrate_add_tensor_product_value_and_gradient_linear(
const unsigned int n_shapes,
- const Number2 * value,
+ const Number2 *value,
const Tensor<1, dim, Number2> &gradient,
- Number2 * values,
- const Point<dim, Number> & p)
+ Number2 *values,
+ const Point<dim, Number> &p)
{
(void)n_shapes;
static_assert(0 <= dim && dim <= 3, "Only dim=0,1,2,3 implemented");
integrate_tensor_product_value_and_gradient(
const dealii::ndarray<Number, 2, dim> *shapes,
const unsigned int n_shapes,
- const Number2 * value,
- const Tensor<1, dim, Number2> & gradient,
- Number2 * values,
- const Point<dim, Number> & p,
+ const Number2 *value,
+ const Tensor<1, dim, Number2> &gradient,
+ Number2 *values,
+ const Point<dim, Number> &p,
const bool is_linear,
const bool do_add)
{
#endif
void
do_apply_test_functions_xy_value(
- Number2 * values,
+ Number2 *values,
const dealii::ndarray<Number, 2, dim> *shapes,
- const Number2 & test_value,
+ const Number2 &test_value,
const int n_shapes_runtime,
- int & i)
+ int &i)
{
if (length > 0)
{
integrate_add_tensor_product_value_shapes(
const dealii::ndarray<Number, 2, dim> *shapes,
const int n_shapes,
- const Number2 & value,
- Number2 * values)
+ const Number2 &value,
+ Number2 *values)
{
static_assert(dim >= 0 && dim <= 3, "Only dim=0,1,2,3 implemented");
template <int dim, typename Number, typename Number2, bool add>
inline void
integrate_add_tensor_product_value_linear(const unsigned int n_shapes,
- const Number2 & value,
- Number2 * values,
+ const Number2 &value,
+ Number2 *values,
const Point<dim, Number> &p)
{
(void)n_shapes;
inline void
integrate_tensor_product_value(const dealii::ndarray<Number, 2, dim> *shapes,
const unsigned int n_shapes,
- const Number2 & value,
- Number2 * values,
+ const Number2 &value,
+ Number2 *values,
const Point<dim, Number> &p,
const bool is_linear,
const bool do_add)
template <int dim, int n_points_1d_template, typename Number>
inline void
- weight_fe_q_dofs_by_entity(const Number * weights,
+ weight_fe_q_dofs_by_entity(const Number *weights,
const unsigned int n_components,
const int n_points_1d_non_template,
- Number * data)
+ Number *data)
{
const int n_points_1d = n_points_1d_template != -1 ?
n_points_1d_template :
template <int dim, int n_points_1d_template, typename Number>
inline void
- weight_fe_q_dofs_by_entity_shifted(const Number * weights,
+ weight_fe_q_dofs_by_entity_shifted(const Number *weights,
const unsigned int n_components,
const int n_points_1d_non_template,
- Number * data)
+ Number *data)
{
const int n_points_1d = n_points_1d_template != -1 ?
n_points_1d_template :
template <int dim, int n_points_1d_template, typename Number>
inline bool
- compute_weights_fe_q_dofs_by_entity(const Number * data,
+ compute_weights_fe_q_dofs_by_entity(const Number *data,
const unsigned int n_components,
const int n_points_1d_non_template,
- Number * weights)
+ Number *weights)
{
const int n_points_1d = n_points_1d_template != -1 ?
n_points_1d_template :
template <int dim, int n_points_1d_template, typename Number>
inline bool
compute_weights_fe_q_dofs_by_entity_shifted(
- const Number * data,
+ const Number *data,
const unsigned int n_components,
const int n_points_1d_non_template,
- Number * weights)
+ Number *weights)
{
const int n_points_1d = n_points_1d_template != -1 ?
n_points_1d_template :
template <int dim, typename AdditionalData>
void
categorize_by_boundary_ids(const Triangulation<dim> &tria,
- AdditionalData & additional_data);
+ AdditionalData &additional_data);
/**
* Compute the diagonal of a linear operator (@p diagonal_global), given
void
compute_diagonal(
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- VectorType & diagonal_global,
+ VectorType &diagonal_global,
const std::function<void(FEEvaluation<dim,
fe_degree,
n_q_points_1d,
void
compute_diagonal(
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- VectorType & diagonal_global,
+ VectorType &diagonal_global,
void (CLASS::*cell_operation)(FEEvaluation<dim,
fe_degree,
n_q_points_1d,
n_components,
Number,
VectorizedArrayType> &) const,
- const CLASS * owning_class,
+ const CLASS *owning_class,
const unsigned int dof_no = 0,
const unsigned int quad_no = 0,
const unsigned int first_selected_component = 0);
typename MatrixType>
void
compute_matrix(
- const MatrixFree<dim, Number, VectorizedArrayType> & matrix_free,
- const AffineConstraints<Number> & constraints,
- MatrixType & matrix,
+ const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
+ const AffineConstraints<Number> &constraints,
+ MatrixType &matrix,
const std::function<void(FEEvaluation<dim,
fe_degree,
n_q_points_1d,
void
compute_matrix(
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- const AffineConstraints<Number> & constraints,
- MatrixType & matrix,
+ const AffineConstraints<Number> &constraints,
+ MatrixType &matrix,
void (CLASS::*cell_operation)(FEEvaluation<dim,
fe_degree,
n_q_points_1d,
n_components,
Number,
VectorizedArrayType> &) const,
- const CLASS * owning_class,
+ const CLASS *owning_class,
const unsigned int dof_no = 0,
const unsigned int quad_no = 0,
const unsigned int first_selected_component = 0);
VectorTypeOut &,
const VectorTypeIn &,
const std::pair<unsigned int, unsigned int> &)> &cell_operation,
- VectorTypeOut & dst,
- const VectorTypeIn & src,
+ VectorTypeOut &dst,
+ const VectorTypeIn &src,
const bool zero_dst_vector = false) const
{
const auto ebd_cell_operation = [&](const auto &matrix_free,
- auto & dst,
+ auto &dst,
const auto &src,
const auto &range) {
const auto category = matrix_free.get_cell_range_category(range);
const VectorTypeIn &,
const std::pair<unsigned int, unsigned int> &,
const bool)> &boundary_operation,
- VectorTypeOut & dst,
- const VectorTypeIn & src,
+ VectorTypeOut &dst,
+ const VectorTypeIn &src,
const bool zero_dst_vector = false) const
{
const auto ebd_cell_operation = [&](const auto &matrix_free,
- auto & dst,
+ auto &dst,
const auto &src,
const auto &range) {
const auto category = matrix_free.get_cell_range_category(range);
const auto ebd_internal_or_boundary_face_operation =
[&](const auto &matrix_free,
- auto & dst,
+ auto &dst,
const auto &src,
const auto &range) {
const auto category = matrix_free.get_face_range_category(range);
template <int dim, typename AdditionalData>
void
categorize_by_boundary_ids(const Triangulation<dim> &tria,
- AdditionalData & additional_data)
+ AdditionalData &additional_data)
{
// ... determine if we are on an active or a multigrid level
const unsigned int level = additional_data.mg_level;
this->phi->reinit(cell);
// STEP 1: get relevant information from FEEvaluation
- const auto & dof_info = phi->get_dof_info();
+ const auto &dof_info = phi->get_dof_info();
const unsigned int n_fe_components = dof_info.start_components.back();
- const auto & matrix_free = phi->get_matrix_free();
+ const auto &matrix_free = phi->get_matrix_free();
// if we have a block vector with components with the same DoFHandler,
// each component is described with same set of constraints and
void
compute_diagonal(
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- VectorType & diagonal_global,
+ VectorType &diagonal_global,
const std::function<void(FEEvaluation<dim,
fe_degree,
n_q_points_1d,
void
compute_diagonal(
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- VectorType & diagonal_global,
+ VectorType &diagonal_global,
void (CLASS::*cell_operation)(FEEvaluation<dim,
fe_degree,
n_q_points_1d,
n_components,
Number,
VectorizedArrayType> &) const,
- const CLASS * owning_class,
+ const CLASS *owning_class,
const unsigned int dof_no,
const unsigned int quad_no,
const unsigned int first_selected_component)
void
compute_matrix(
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- const AffineConstraints<Number> & constraints_in,
- MatrixType & matrix,
+ const AffineConstraints<Number> &constraints_in,
+ MatrixType &matrix,
const std::function<void(FEEvaluation<dim,
fe_degree,
n_q_points_1d,
void
compute_matrix(
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- const AffineConstraints<Number> & constraints,
- MatrixType & matrix,
+ const AffineConstraints<Number> &constraints,
+ MatrixType &matrix,
void (CLASS::*cell_operation)(FEEvaluation<dim,
fe_degree,
n_q_points_1d,
n_components,
Number,
VectorizedArrayType> &) const,
- const CLASS * owning_class,
+ const CLASS *owning_class,
const unsigned int dof_no,
const unsigned int quad_no,
const unsigned int first_selected_component)
// We assume that if both begin() and local_element()
// exist, then begin() + offset == local_element(offset)
template <typename T>
- constexpr bool has_exchange_on_subset =
- has_begin<T> &&has_local_element<T> &&has_partitioners_are_compatible<T>;
+ constexpr bool has_exchange_on_subset =
+ has_begin<T> && has_local_element<T> && has_partitioners_are_compatible<T>;
typename VectorType,
std::enable_if_t<has_add_local_element<VectorType>, VectorType> * = nullptr>
inline void
- vector_access_add(VectorType & vec,
+ vector_access_add(VectorType &vec,
const unsigned int entry,
const typename VectorType::value_type &val)
{
std::enable_if_t<!has_add_local_element<VectorType>, VectorType> * =
nullptr>
inline void
- vector_access_add(VectorType & vec,
+ vector_access_add(VectorType &vec,
const unsigned int entry,
const typename VectorType::value_type &val)
{
typename VectorType,
std::enable_if_t<has_add_local_element<VectorType>, VectorType> * = nullptr>
inline void
- vector_access_add_global(VectorType & vec,
+ vector_access_add_global(VectorType &vec,
const types::global_dof_index entry,
const typename VectorType::value_type &val)
{
std::enable_if_t<!has_add_local_element<VectorType>, VectorType> * =
nullptr>
inline void
- vector_access_add_global(VectorType & vec,
+ vector_access_add_global(VectorType &vec,
const types::global_dof_index entry,
const typename VectorType::value_type &val)
{
typename VectorType,
std::enable_if_t<has_set_local_element<VectorType>, VectorType> * = nullptr>
inline void
- vector_access_set(VectorType & vec,
+ vector_access_set(VectorType &vec,
const unsigned int entry,
const typename VectorType::value_type &val)
{
std::enable_if_t<!has_set_local_element<VectorType>, VectorType> * =
nullptr>
inline void
- vector_access_set(VectorType & vec,
+ vector_access_set(VectorType &vec,
const unsigned int entry,
const typename VectorType::value_type &val)
{
VectorType> * = nullptr>
inline void
check_vector_compatibility(
- const VectorType & vec,
+ const VectorType &vec,
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- const internal::MatrixFreeFunctions::DoFInfo & dof_info)
+ const internal::MatrixFreeFunctions::DoFInfo &dof_info)
{
(void)vec;
(void)matrix_free;
VectorType> * = nullptr>
inline void
check_vector_compatibility(
- const VectorType & vec,
+ const VectorType &vec,
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- const internal::MatrixFreeFunctions::DoFInfo & dof_info)
+ const internal::MatrixFreeFunctions::DoFInfo &dof_info)
{
(void)vec;
(void)matrix_free;
template <typename VectorType>
void
process_dof(const unsigned int index,
- const VectorType & vec,
- Number & res) const
+ const VectorType &vec,
+ Number &res) const
{
res = vector_access(vec, index);
}
void
process_dofs_vectorized(const unsigned int dofs_per_cell,
const unsigned int dof_index,
- VectorType & vec,
+ VectorType &vec,
VectorizedArrayType *dof_values,
std::integral_constant<bool, true>) const
{
void
process_dofs_vectorized(const unsigned int dofs_per_cell,
const unsigned int dof_index,
- const VectorType & vec,
+ const VectorType &vec,
VectorizedArrayType *dof_values,
std::integral_constant<bool, false>) const
{
template <typename VectorType>
void
process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- VectorType & vec,
+ const unsigned int *dof_indices,
+ VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
std::integral_constant<bool, true>) const
template <typename VectorType>
void
process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- const VectorType & vec,
+ const unsigned int *dof_indices,
+ const VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
std::integral_constant<bool, false>) const
void
process_dofs_vectorized_transpose(
const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- VectorType & vec,
- VectorizedArrayType * dof_values,
+ const unsigned int *dof_indices,
+ VectorType &vec,
+ VectorizedArrayType *dof_values,
std::integral_constant<bool, true> type) const
{
process_dofs_vectorized_transpose(
void
process_dofs_vectorized_transpose(
const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- const VectorType & vec,
- VectorizedArrayType * dof_values,
+ const unsigned int *dof_indices,
+ const VectorType &vec,
+ VectorizedArrayType *dof_values,
std::integral_constant<bool, false> type) const
{
process_dofs_vectorized_transpose(
process_dofs_vectorized_transpose(
const unsigned int dofs_per_cell,
const std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
- VectorizedArrayType * dof_values,
+ VectorizedArrayType *dof_values,
std::integral_constant<bool, true>) const
{
dealii::vectorized_load_and_transpose(dofs_per_cell,
// gather
template <typename VectorType>
void
- process_dof_gather(const unsigned int * indices,
- VectorType & vec,
+ process_dof_gather(const unsigned int *indices,
+ VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType &res,
std::integral_constant<bool, true>) const
// manually load the data
template <typename VectorType>
void
- process_dof_gather(const unsigned int * indices,
- const VectorType & vec,
+ process_dof_gather(const unsigned int *indices,
+ const VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType &res,
std::integral_constant<bool, false>) const
template <typename VectorType>
void
process_dof_global(const types::global_dof_index index,
- const VectorType & vec,
- Number & res) const
+ const VectorType &vec,
+ Number &res) const
{
res = vec(index);
}
void
process_constraint(const unsigned int index,
const Number weight,
- const VectorType & vec,
- Number & res) const
+ const VectorType &vec,
+ Number &res) const
{
res += weight * vector_access(vec, index);
}
void
process_dofs_vectorized(const unsigned int dofs_per_cell,
const unsigned int dof_index,
- VectorType & vec,
+ VectorType &vec,
VectorizedArrayType *dof_values,
std::integral_constant<bool, true>) const
{
void
process_dofs_vectorized(const unsigned int dofs_per_cell,
const unsigned int dof_index,
- VectorType & vec,
+ VectorType &vec,
VectorizedArrayType *dof_values,
std::integral_constant<bool, false>) const
{
template <typename VectorType>
void
process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- VectorType & vec,
+ const unsigned int *dof_indices,
+ VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
std::integral_constant<bool, true>) const
template <typename VectorType>
void
process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- VectorType & vec,
+ const unsigned int *dof_indices,
+ VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
std::integral_constant<bool, false>) const
void
process_dofs_vectorized_transpose(
const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- VectorType & vec,
- VectorizedArrayType * dof_values,
+ const unsigned int *dof_indices,
+ VectorType &vec,
+ VectorizedArrayType *dof_values,
std::integral_constant<bool, true> type) const
{
process_dofs_vectorized_transpose(
void
process_dofs_vectorized_transpose(
const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- VectorType & vec,
- VectorizedArrayType * dof_values,
+ const unsigned int *dof_indices,
+ VectorType &vec,
+ VectorizedArrayType *dof_values,
std::integral_constant<bool, false> type) const
{
process_dofs_vectorized_transpose(
process_dofs_vectorized_transpose(
const unsigned int dofs_per_cell,
std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
- VectorizedArrayType * dof_values,
+ VectorizedArrayType *dof_values,
std::integral_constant<bool, true>) const
{
vectorized_transpose_and_store(true,
// scatter
template <typename VectorType>
void
- process_dof_gather(const unsigned int * indices,
- VectorType & vec,
+ process_dof_gather(const unsigned int *indices,
+ VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType &res,
std::integral_constant<bool, true>) const
// manually append all data
template <typename VectorType>
void
- process_dof_gather(const unsigned int * indices,
- VectorType & vec,
+ process_dof_gather(const unsigned int *indices,
+ VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType &res,
std::integral_constant<bool, false>) const
template <typename VectorType>
void
process_dof_global(const types::global_dof_index index,
- VectorType & vec,
- Number & res) const
+ VectorType &vec,
+ Number &res) const
{
vector_access_add_global(vec, index, res);
}
void
process_constraint(const unsigned int index,
const Number weight,
- VectorType & vec,
- Number & res) const
+ VectorType &vec,
+ Number &res) const
{
vector_access_add(vec, index, weight * res);
}
void
process_dofs_vectorized(const unsigned int dofs_per_cell,
const unsigned int dof_index,
- VectorType & vec,
+ VectorType &vec,
VectorizedArrayType *dof_values,
std::integral_constant<bool, true>) const
{
void
process_dofs_vectorized(const unsigned int dofs_per_cell,
const unsigned int dof_index,
- VectorType & vec,
+ VectorType &vec,
VectorizedArrayType *dof_values,
std::integral_constant<bool, false>) const
{
template <typename VectorType>
void
process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- VectorType & vec,
+ const unsigned int *dof_indices,
+ VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
std::integral_constant<bool, true>) const
template <typename VectorType, bool booltype>
void
process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- VectorType & vec,
+ const unsigned int *dof_indices,
+ VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
std::integral_constant<bool, false>) const
void
process_dofs_vectorized_transpose(
const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- VectorType & vec,
- VectorizedArrayType * dof_values,
+ const unsigned int *dof_indices,
+ VectorType &vec,
+ VectorizedArrayType *dof_values,
std::integral_constant<bool, true> type) const
{
process_dofs_vectorized_transpose(
void
process_dofs_vectorized_transpose(
const unsigned int dofs_per_cell,
- const unsigned int * dof_indices,
- VectorType & vec,
- VectorizedArrayType * dof_values,
+ const unsigned int *dof_indices,
+ VectorType &vec,
+ VectorizedArrayType *dof_values,
std::integral_constant<bool, false> type) const
{
process_dofs_vectorized_transpose(
process_dofs_vectorized_transpose(
const unsigned int dofs_per_cell,
std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
- VectorizedArrayType * dof_values,
+ VectorizedArrayType *dof_values,
std::integral_constant<bool, true>) const
{
vectorized_transpose_and_store(false,
template <typename VectorType>
void
- process_dof_gather(const unsigned int * indices,
- VectorType & vec,
+ process_dof_gather(const unsigned int *indices,
+ VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType &res,
std::integral_constant<bool, true>) const
template <typename VectorType>
void
- process_dof_gather(const unsigned int * indices,
- VectorType & vec,
+ process_dof_gather(const unsigned int *indices,
+ VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType &res,
std::integral_constant<bool, false>) const
template <typename VectorType>
void
process_dof_global(const types::global_dof_index index,
- VectorType & vec,
- Number & res) const
+ VectorType &vec,
+ Number &res) const
{
vec(index) = res;
}
virtual void
export_to_ghosted_array_start(
const unsigned int communication_channel,
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<double> & temporary_storage,
- std::vector<MPI_Request> & requests) const = 0;
+ const ArrayView<double> &ghost_array,
+ const ArrayView<double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const = 0;
virtual void
export_to_ghosted_array_finish(
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- std::vector<MPI_Request> & requests) const = 0;
+ const ArrayView<double> &ghost_array,
+ std::vector<MPI_Request> &requests) const = 0;
virtual void
import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<double> & temporary_storage,
- std::vector<MPI_Request> & requests) const = 0;
+ const ArrayView<double> &ghost_array,
+ const ArrayView<double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const = 0;
virtual void
import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
- const ArrayView<double> & locally_owned_storage,
+ const ArrayView<double> &locally_owned_storage,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<const double> & temporary_storage,
- std::vector<MPI_Request> & requests) const = 0;
+ const ArrayView<double> &ghost_array,
+ const ArrayView<const double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const = 0;
virtual void
reset_ghost_values(const ArrayView<double> &ghost_array) const = 0;
virtual void
export_to_ghosted_array_start(
const unsigned int communication_channel,
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<float> & temporary_storage,
- std::vector<MPI_Request> & requests) const = 0;
+ const ArrayView<float> &ghost_array,
+ const ArrayView<float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const = 0;
virtual void
export_to_ghosted_array_finish(
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- std::vector<MPI_Request> & requests) const = 0;
+ const ArrayView<float> &ghost_array,
+ std::vector<MPI_Request> &requests) const = 0;
virtual void
import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<float> & temporary_storage,
- std::vector<MPI_Request> & requests) const = 0;
+ const ArrayView<float> &ghost_array,
+ const ArrayView<float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const = 0;
virtual void
import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
- const ArrayView<float> & locally_owned_storage,
+ const ArrayView<float> &locally_owned_storage,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<const float> & temporary_storage,
- std::vector<MPI_Request> & requests) const = 0;
+ const ArrayView<float> &ghost_array,
+ const ArrayView<const float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const = 0;
virtual void
reset_ghost_values(const ArrayView<float> &ghost_array) const = 0;
void
export_to_ghosted_array_start(
const unsigned int communication_channel,
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<double> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<double> &ghost_array,
+ const ArrayView<double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
export_to_ghosted_array_finish(
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<double> &ghost_array,
+ std::vector<MPI_Request> &requests) const override;
void
import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<double> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<double> &ghost_array,
+ const ArrayView<double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
- const ArrayView<double> & locally_owned_storage,
+ const ArrayView<double> &locally_owned_storage,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<const double> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<double> &ghost_array,
+ const ArrayView<const double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
reset_ghost_values(const ArrayView<double> &ghost_array) const override;
void
export_to_ghosted_array_start(
const unsigned int communication_channel,
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<float> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<float> &ghost_array,
+ const ArrayView<float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
export_to_ghosted_array_finish(
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<float> &ghost_array,
+ std::vector<MPI_Request> &requests) const override;
void
import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<float> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<float> &ghost_array,
+ const ArrayView<float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
- const ArrayView<float> & locally_owned_storage,
+ const ArrayView<float> &locally_owned_storage,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<const float> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<float> &ghost_array,
+ const ArrayView<const float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
reset_ghost_values(const ArrayView<float> &ghost_array) const override;
void
export_to_ghosted_array_start(
const unsigned int communication_channel,
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<double> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<double> &ghost_array,
+ const ArrayView<double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
export_to_ghosted_array_finish(
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<double> &ghost_array,
+ std::vector<MPI_Request> &requests) const override;
void
import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<double> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<double> &ghost_array,
+ const ArrayView<double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
- const ArrayView<double> & locally_owned_storage,
+ const ArrayView<double> &locally_owned_storage,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<const double> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<double> &ghost_array,
+ const ArrayView<const double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
reset_ghost_values(const ArrayView<double> &ghost_array) const override;
void
export_to_ghosted_array_start(
const unsigned int communication_channel,
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<float> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<float> &ghost_array,
+ const ArrayView<float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
export_to_ghosted_array_finish(
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<float> &ghost_array,
+ std::vector<MPI_Request> &requests) const override;
void
import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<float> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<float> &ghost_array,
+ const ArrayView<float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
- const ArrayView<float> & locally_owned_storage,
+ const ArrayView<float> &locally_owned_storage,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<const float> & temporary_storage,
- std::vector<MPI_Request> & requests) const override;
+ const ArrayView<float> &ghost_array,
+ const ArrayView<const float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const override;
void
reset_ghost_values(const ArrayView<float> &ghost_array) const override;
void
export_to_ghosted_array_start_impl(
const unsigned int communication_channel,
- const ArrayView<const Number> & locally_owned_array,
+ const ArrayView<const Number> &locally_owned_array,
const std::vector<ArrayView<const Number>> &shared_arrays,
- const ArrayView<Number> & ghost_array,
- const ArrayView<Number> & temporary_storage,
- std::vector<MPI_Request> & requests) const;
+ const ArrayView<Number> &ghost_array,
+ const ArrayView<Number> &temporary_storage,
+ std::vector<MPI_Request> &requests) const;
template <typename Number>
void
export_to_ghosted_array_finish_impl(
- const ArrayView<const Number> & locally_owned_array,
+ const ArrayView<const Number> &locally_owned_array,
const std::vector<ArrayView<const Number>> &shared_arrays,
- const ArrayView<Number> & ghost_array,
- std::vector<MPI_Request> & requests) const;
+ const ArrayView<Number> &ghost_array,
+ std::vector<MPI_Request> &requests) const;
template <typename Number>
void
import_from_ghosted_array_start_impl(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<const Number> & locally_owned_array,
+ const ArrayView<const Number> &locally_owned_array,
const std::vector<ArrayView<const Number>> &shared_arrays,
- const ArrayView<Number> & ghost_array,
- const ArrayView<Number> & temporary_storage,
- std::vector<MPI_Request> & requests) const;
+ const ArrayView<Number> &ghost_array,
+ const ArrayView<Number> &temporary_storage,
+ std::vector<MPI_Request> &requests) const;
template <typename Number>
void
import_from_ghosted_array_finish_impl(
const VectorOperation::values vector_operation,
- const ArrayView<Number> & locally_owned_storage,
+ const ArrayView<Number> &locally_owned_storage,
const std::vector<ArrayView<const Number>> &shared_arrays,
- const ArrayView<Number> & ghost_array,
- const ArrayView<const Number> & temporary_storage,
- std::vector<MPI_Request> & requests) const;
+ const ArrayView<Number> &ghost_array,
+ const ArrayView<const Number> &temporary_storage,
+ std::vector<MPI_Request> &requests) const;
template <typename Number>
void
* Assemble a single local residual into the global.
*/
void
- assemble(VectorType & global,
- const BlockVector<double> & local,
+ assemble(VectorType &global,
+ const BlockVector<double> &local,
const std::vector<types::global_dof_index> &dof);
/**
* initialize cell matrix vectors.
*/
void
- initialize(const BlockInfo * block_info,
+ initialize(const BlockInfo *block_info,
MatrixBlockVector<MatrixType> &matrices);
/**
* Assemble a single local matrix into a global one.
*/
void
- assemble(MatrixBlock<MatrixType> & global,
- const FullMatrix<number> & local,
+ assemble(MatrixBlock<MatrixType> &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
* Assemble a single local matrix into a global one.
*/
void
- assemble(MatrixType & global,
- const FullMatrix<number> & local,
+ assemble(MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
* Assemble a single local matrix into a global one.
*/
void
- assemble_fluxes(MatrixType & global,
- const FullMatrix<number> & local,
+ assemble_fluxes(MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
* Assemble a single local matrix into a global one.
*/
void
- assemble_up(MatrixType & global,
- const FullMatrix<number> & local,
+ assemble_up(MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
* Assemble a single local matrix into a global one.
*/
void
- assemble_down(MatrixType & global,
- const FullMatrix<number> & local,
+ assemble_down(MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
* Assemble a single local matrix into a global one.
*/
void
- assemble_in(MatrixType & global,
- const FullMatrix<number> & local,
+ assemble_in(MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
* Assemble a single local matrix into a global one.
*/
void
- assemble_out(MatrixType & global,
- const FullMatrix<number> & local,
+ assemble_out(MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
inline void
ResidualLocalBlocksToGlobalBlocks<VectorType>::initialize(
const BlockInfo *b,
- AnyData & m)
+ AnyData &m)
{
block_info = b;
residuals = m;
template <typename VectorType>
inline void
ResidualLocalBlocksToGlobalBlocks<VectorType>::assemble(
- VectorType & global,
- const BlockVector<double> & local,
+ VectorType &global,
+ const BlockVector<double> &local,
const std::vector<types::global_dof_index> &dof)
{
if (constraints == 0)
template <typename MatrixType, typename number>
inline void
MatrixLocalBlocksToGlobalBlocks<MatrixType, number>::initialize(
- const BlockInfo * b,
+ const BlockInfo *b,
MatrixBlockVector<MatrixType> &m)
{
block_info = b;
template <typename MatrixType, typename number>
inline void
MatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble(
- MatrixBlock<MatrixType> & global,
- const FullMatrix<number> & local,
+ MatrixBlock<MatrixType> &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
}
else
{
- const BlockIndices & bi = this->block_info->local();
+ const BlockIndices &bi = this->block_info->local();
std::vector<types::global_dof_index> sliced_row_indices(
bi.block_size(block_row));
for (unsigned int i = 0; i < sliced_row_indices.size(); ++i)
template <typename MatrixType, typename number>
inline void
MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble(
- MatrixType & global,
- const FullMatrix<number> & local,
+ MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
template <typename MatrixType, typename number>
inline void
MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble_fluxes(
- MatrixType & global,
- const FullMatrix<number> & local,
+ MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
template <typename MatrixType, typename number>
inline void
MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble_up(
- MatrixType & global,
- const FullMatrix<number> & local,
+ MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
template <typename MatrixType, typename number>
inline void
MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble_down(
- MatrixType & global,
- const FullMatrix<number> & local,
+ MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
template <typename MatrixType, typename number>
inline void
MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble_in(
- MatrixType & global,
- const FullMatrix<number> & local,
+ MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
template <typename MatrixType, typename number>
inline void
MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble_out(
- MatrixType & global,
- const FullMatrix<number> & local,
+ MatrixType &global,
+ const FullMatrix<number> &local,
const unsigned int block_row,
const unsigned int block_col,
const std::vector<types::global_dof_index> &dof1,
* For every object, specify the size they should have.
*/
explicit CopyData(
- const ndarray<unsigned int, n_matrices, 2> & matrix_sizes,
- const std::array<unsigned int, n_vectors> & vector_sizes,
+ const ndarray<unsigned int, n_matrices, 2> &matrix_sizes,
+ const std::array<unsigned int, n_vectors> &vector_sizes,
const std::array<unsigned int, n_dof_indices> &dof_indices_sizes);
/**
int n_dof_indices,
typename ScalarType>
CopyData<n_matrices, n_vectors, n_dof_indices, ScalarType>::CopyData(
- const ndarray<unsigned int, n_matrices, 2> & matrix_sizes,
- const std::array<unsigned int, n_vectors> & vector_sizes,
+ const ndarray<unsigned int, n_matrices, 2> &matrix_sizes,
+ const std::array<unsigned int, n_vectors> &vector_sizes,
const std::array<unsigned int, n_dof_indices> &dof_indices_sizes)
{
for (unsigned int i = 0; i < n_matrices; ++i)
*/
template <class FEVALUES>
void
- initialize(const FiniteElement<dim, spacedim> & el,
- const Mapping<dim, spacedim> & mapping,
+ initialize(const FiniteElement<dim, spacedim> &el,
+ const Mapping<dim, spacedim> &mapping,
const Quadrature<FEVALUES::integral_dimension> &quadrature,
const UpdateFlags flags,
const BlockInfo *local_block_info = nullptr);
template <typename TYPE>
void
fill_local_data(std::vector<std::vector<std::vector<TYPE>>> &data,
- VectorSelector & selector,
+ VectorSelector &selector,
bool split_fevalues) const;
/**
* Cache the number of components of the system element.
*/
void
initialize(const FiniteElement<dim, spacedim> &el,
- const Mapping<dim, spacedim> & mapping,
- const BlockInfo * block_info = nullptr);
+ const Mapping<dim, spacedim> &mapping,
+ const BlockInfo *block_info = nullptr);
/**
* Initialize the IntegrationInfo objects contained.
template <typename VectorType>
void
initialize(const FiniteElement<dim, spacedim> &el,
- const Mapping<dim, spacedim> & mapping,
- const AnyData & data,
- const VectorType & dummy,
- const BlockInfo * block_info = nullptr);
+ const Mapping<dim, spacedim> &mapping,
+ const AnyData &data,
+ const VectorType &dummy,
+ const BlockInfo *block_info = nullptr);
/**
* Initialize the IntegrationInfo objects contained.
*
template <typename VectorType>
void
initialize(const FiniteElement<dim, spacedim> &el,
- const Mapping<dim, spacedim> & mapping,
- const AnyData & data,
- const MGLevelObject<VectorType> & dummy,
- const BlockInfo * block_info = nullptr);
+ const Mapping<dim, spacedim> &mapping,
+ const AnyData &data,
+ const MGLevelObject<VectorType> &dummy,
+ const BlockInfo *block_info = nullptr);
/**
* @name FEValues setup
* @{
for (unsigned int i = 0; i < other.fevalv.size(); ++i)
{
const FEValuesBase<dim, sdim> &p = *other.fevalv[i];
- const FEValues<dim, sdim> * pc =
+ const FEValues<dim, sdim> *pc =
dynamic_cast<const FEValues<dim, sdim> *>(&p);
const FEFaceValues<dim, sdim> *pf =
dynamic_cast<const FEFaceValues<dim, sdim> *>(&p);
template <class FEVALUES>
inline void
IntegrationInfo<dim, sdim>::initialize(
- const FiniteElement<dim, sdim> & el,
- const Mapping<dim, sdim> & mapping,
+ const FiniteElement<dim, sdim> &el,
+ const Mapping<dim, sdim> &mapping,
const Quadrature<FEVALUES::integral_dimension> &quadrature,
const UpdateFlags flags,
- const BlockInfo * block_info)
+ const BlockInfo *block_info)
{
fe_pointer = ⪙
if (block_info == nullptr || block_info->local().size() == 0)
void
IntegrationInfoBox<dim, sdim>::initialize(const FiniteElement<dim, sdim> &el,
const Mapping<dim, sdim> &mapping,
- const AnyData & data,
+ const AnyData &data,
const VectorType &,
const BlockInfo *block_info)
{
initialize(el, mapping, block_info);
std::shared_ptr<VectorData<VectorType, dim, sdim>> p;
- VectorDataBase<dim, sdim> * pp;
+ VectorDataBase<dim, sdim> *pp;
p = std::make_shared<VectorData<VectorType, dim, sdim>>(cell_selector);
// Public member function of parent class was not found without
void
IntegrationInfoBox<dim, sdim>::initialize(const FiniteElement<dim, sdim> &el,
const Mapping<dim, sdim> &mapping,
- const AnyData & data,
+ const AnyData &data,
const MGLevelObject<VectorType> &,
const BlockInfo *block_info)
{
initialize(el, mapping, block_info);
std::shared_ptr<MGVectorData<VectorType, dim, sdim>> p;
- VectorDataBase<dim, sdim> * pp;
+ VectorDataBase<dim, sdim> *pp;
p = std::make_shared<MGVectorData<VectorType, dim, sdim>>(cell_selector);
// Public member function of parent class was not found without
cell_action(
ITERATOR cell,
DoFInfoBox<dim, DOFINFO> &dof_info,
- INFOBOX & info,
+ INFOBOX &info,
const std::function<void(DOFINFO &, typename INFOBOX::CellInfo &)>
&cell_worker,
const std::function<void(DOFINFO &, typename INFOBOX::CellInfo &)>
- & boundary_worker,
+ &boundary_worker,
const std::function<void(DOFINFO &,
DOFINFO &,
typename INFOBOX::CellInfo &,
typename INFOBOX::CellInfo &)> &face_worker,
- const LoopControl & loop_control)
+ const LoopControl &loop_control)
{
const bool ignore_subdomain =
(cell->get_triangulation().locally_owned_subdomain() ==
void
loop(ITERATOR begin,
std_cxx20::type_identity_t<ITERATOR> end,
- DOFINFO & dinfo,
- INFOBOX & info,
+ DOFINFO &dinfo,
+ INFOBOX &info,
const std::function<void(DOFINFO &, typename INFOBOX::CellInfo &)>
&cell_worker,
const std::function<void(DOFINFO &, typename INFOBOX::CellInfo &)>
- & boundary_worker,
+ &boundary_worker,
const std::function<void(DOFINFO &,
DOFINFO &,
typename INFOBOX::CellInfo &,
typename INFOBOX::CellInfo &)> &face_worker,
- ASSEMBLER & assembler,
+ ASSEMBLER &assembler,
const LoopControl &lctrl = LoopControl())
{
DoFInfoBox<dim, DOFINFO> dof_info(dinfo);
void
integration_loop(ITERATOR begin,
std_cxx20::type_identity_t<ITERATOR> end,
- DoFInfo<dim, spacedim> & dof_info,
- IntegrationInfoBox<dim, spacedim> & box,
+ DoFInfo<dim, spacedim> &dof_info,
+ IntegrationInfoBox<dim, spacedim> &box,
const LocalIntegrator<dim, spacedim> &integrator,
- ASSEMBLER & assembler,
- const LoopControl & lctrl = LoopControl())
+ ASSEMBLER &assembler,
+ const LoopControl &lctrl = LoopControl())
{
std::function<void(DoFInfo<dim, spacedim> &,
IntegrationInfo<dim, spacedim> &)>
face_worker;
if (integrator.use_cell)
cell_worker =
- [&integrator](DoFInfo<dim, spacedim> & dof_info,
+ [&integrator](DoFInfo<dim, spacedim> &dof_info,
IntegrationInfo<dim, spacedim> &integration_info) {
integrator.cell(dof_info, integration_info);
};
if (integrator.use_boundary)
boundary_worker =
- [&integrator](DoFInfo<dim, spacedim> & dof_info,
+ [&integrator](DoFInfo<dim, spacedim> &dof_info,
IntegrationInfo<dim, spacedim> &integration_info) {
integrator.boundary(dof_info, integration_info);
};
if (integrator.use_face)
face_worker =
- [&integrator](DoFInfo<dim, spacedim> & dof_info_1,
- DoFInfo<dim, spacedim> & dof_info_2,
+ [&integrator](DoFInfo<dim, spacedim> &dof_info_1,
+ DoFInfo<dim, spacedim> &dof_info_2,
IntegrationInfo<dim, spacedim> &integration_info_1,
IntegrationInfo<dim, spacedim> &integration_info_2) {
integrator.face(dof_info_1,
const CellIteratorType &end,
const CellWorkerFunctionType &cell_worker,
- const CopierType & copier,
+ const CopierType &copier,
const ScratchData &sample_scratch_data,
- const CopyData & sample_copy_data,
+ const CopyData &sample_copy_data,
const AssembleFlags flags = assemble_own_cells,
const unsigned int queue_length = 2 * MultithreadInfo::n_threads(),
const unsigned int chunk_size = 8
#else
- const CellIteratorType & begin,
+ const CellIteratorType &begin,
const std_cxx20::type_identity_t<CellIteratorType> &end,
const std_cxx20::type_identity_t<std::function<
&copier,
const ScratchData &sample_scratch_data,
- const CopyData & sample_copy_data,
+ const CopyData &sample_copy_data,
const AssembleFlags flags = assemble_own_cells,
"conditions is not satisfied."));
auto cell_action = [&](const CellIteratorBaseType &cell,
- ScratchData & scratch,
- CopyData & copy) {
+ ScratchData &scratch,
+ CopyData ©) {
// First reset the CopyData class to the empty copy_data given by the
// user.
copy = sample_copy_data;
&copier,
const ScratchData &sample_scratch_data,
- const CopyData & sample_copy_data,
+ const CopyData &sample_copy_data,
const AssembleFlags flags = assemble_own_cells,
class CopyData,
class MainClass>
void
- mesh_loop(const CellIteratorType & begin,
+ mesh_loop(const CellIteratorType &begin,
const std_cxx20::type_identity_t<CellIteratorType> &end,
- MainClass & main_class,
+ MainClass &main_class,
void (MainClass::*cell_worker)(const CellIteratorType &,
ScratchData &,
CopyData &),
void (MainClass::*copier)(const CopyData &),
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data,
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data,
const AssembleFlags flags = assemble_own_cells,
void (MainClass::*boundary_worker)(const CellIteratorType &,
const unsigned int,
if (cell_worker != nullptr)
f_cell_worker = [&main_class,
cell_worker](const CellIteratorType &cell_iterator,
- ScratchData & scratch_data,
- CopyData & copy_data) {
+ ScratchData &scratch_data,
+ CopyData ©_data) {
(main_class.*cell_worker)(cell_iterator, scratch_data, copy_data);
};
f_boundary_worker =
[&main_class, boundary_worker](const CellIteratorType &cell_iterator,
const unsigned int face_no,
- ScratchData & scratch_data,
- CopyData & copy_data) {
+ ScratchData &scratch_data,
+ CopyData ©_data) {
(main_class.*
boundary_worker)(cell_iterator, face_no, scratch_data, copy_data);
};
const CellIteratorType &cell_iterator_2,
const unsigned int face_index_2,
const unsigned int subface_index_2,
- ScratchData & scratch_data,
- CopyData & copy_data) {
+ ScratchData &scratch_data,
+ CopyData ©_data) {
(main_class.*face_worker)(cell_iterator_1,
face_index_1,
subface_index_1,
typename internal::CellIteratorBaseType<CellIteratorType>::type>
void
mesh_loop(IteratorRange<CellIteratorType> iterator_range,
- MainClass & main_class,
+ MainClass &main_class,
void (MainClass::*cell_worker)(const CellIteratorBaseType &,
ScratchData &,
CopyData &),
void (MainClass::*copier)(const CopyData &),
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data,
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data,
const AssembleFlags flags = assemble_own_cells,
void (MainClass::*boundary_worker)(const CellIteratorBaseType &,
const unsigned int,
* FESubfaceValues for both the current cell and the neighbor cell
*/
ScratchData(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- const UpdateFlags & update_flags,
+ const Quadrature<dim> &quadrature,
+ const UpdateFlags &update_flags,
const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
- const UpdateFlags & face_update_flags = update_default);
+ const UpdateFlags &face_update_flags = update_default);
/**
* Similar to the other constructor, but this one allows to specify
* FESubfaceValues for the neighbor cell
*/
ScratchData(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- const UpdateFlags & update_flags,
- const UpdateFlags & neighbor_update_flags,
+ const Quadrature<dim> &quadrature,
+ const UpdateFlags &update_flags,
+ const UpdateFlags &neighbor_update_flags,
const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
- const UpdateFlags & face_update_flags = update_default,
- const UpdateFlags & neighbor_face_update_flags = update_default);
+ const UpdateFlags &face_update_flags = update_default,
+ const UpdateFlags &neighbor_face_update_flags = update_default);
/**
* Same as the other constructor, using the default linear mapping.
*/
ScratchData(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- const UpdateFlags & update_flags,
+ const Quadrature<dim> &quadrature,
+ const UpdateFlags &update_flags,
const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
- const UpdateFlags & face_update_flags = update_default);
+ const UpdateFlags &face_update_flags = update_default);
/**
* Same as the other constructor, using the default linear mapping.
*/
ScratchData(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- const UpdateFlags & update_flags,
- const UpdateFlags & neighbor_update_flags,
+ const Quadrature<dim> &quadrature,
+ const UpdateFlags &update_flags,
+ const UpdateFlags &neighbor_update_flags,
const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
- const UpdateFlags & face_update_flags = update_default,
- const UpdateFlags & neighbor_face_update_flags = update_default);
+ const UpdateFlags &face_update_flags = update_default,
+ const UpdateFlags &neighbor_face_update_flags = update_default);
/**
* Create an empty ScratchData object. A SmartPointer pointing to
* hp::FESubfaceValues for both the current cell and the neighbor cell
*/
ScratchData(const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const hp::FECollection<dim, spacedim> & fe_collection,
- const hp::QCollection<dim> & cell_quadrature_collection,
- const UpdateFlags & cell_update_flags,
+ const hp::FECollection<dim, spacedim> &fe_collection,
+ const hp::QCollection<dim> &cell_quadrature_collection,
+ const UpdateFlags &cell_update_flags,
const hp::QCollection<dim - 1> &face_quadrature_collection =
hp::QCollection<dim - 1>(),
const UpdateFlags &face_update_flags = update_default);
* hp::FESubfaceValues for the neighbor cell
*/
ScratchData(const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const hp::FECollection<dim, spacedim> & fe_collection,
- const hp::QCollection<dim> & cell_quadrature_collection,
- const UpdateFlags & cell_update_flags,
- const UpdateFlags & neighbor_cell_update_flags,
+ const hp::FECollection<dim, spacedim> &fe_collection,
+ const hp::QCollection<dim> &cell_quadrature_collection,
+ const UpdateFlags &cell_update_flags,
+ const UpdateFlags &neighbor_cell_update_flags,
const hp::QCollection<dim - 1> &face_quadrature_collection =
hp::QCollection<dim - 1>(),
const UpdateFlags &face_update_flags = update_default,
* hp::FESubfaceValues for both the current cell and the neighbor cell
*/
ScratchData(const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & cell_quadrature_collection,
- const UpdateFlags & cell_update_flags,
+ const hp::QCollection<dim> &cell_quadrature_collection,
+ const UpdateFlags &cell_update_flags,
const hp::QCollection<dim - 1> &face_quadrature_collection =
hp::QCollection<dim - 1>(),
const UpdateFlags &face_update_flags = update_default);
* hp::FESubfaceValues for the neighbor cell
*/
ScratchData(const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & cell_quadrature_collection,
- const UpdateFlags & cell_update_flags,
- const UpdateFlags & neighbor_cell_update_flags,
+ const hp::QCollection<dim> &cell_quadrature_collection,
+ const UpdateFlags &cell_update_flags,
+ const UpdateFlags &neighbor_cell_update_flags,
const hp::QCollection<dim - 1> &face_quadrature_collection =
hp::QCollection<dim - 1>(),
const UpdateFlags &face_update_flags = update_default,
reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const unsigned int face_no,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & cell_neighbor,
+ &cell_neighbor,
const unsigned int face_no_neighbor);
/**
const unsigned int face_no,
const unsigned int sub_face_no,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & cell_neighbor,
+ &cell_neighbor,
const unsigned int face_no_neighbor,
const unsigned int sub_face_no_neighbor);
const FEFaceValues<dim, spacedim> &
reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & neighbor_cell,
+ &neighbor_cell,
const unsigned int face_no);
/**
const FEFaceValuesBase<dim, spacedim> &
reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & neighbor_cell,
+ &neighbor_cell,
const unsigned int face_no,
const unsigned int subface_no);
reinit_neighbor(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & neighbor_cell,
+ &neighbor_cell,
const unsigned int face_no);
/**
reinit_neighbor(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & neighbor_cell,
+ &neighbor_cell,
const unsigned int face_no,
const unsigned int subface_no);
template <typename VectorType, typename Number = double>
void
extract_local_dof_values(const std::string &global_vector_name,
- const VectorType & input_vector,
+ const VectorType &input_vector,
const Number dummy = Number(0));
/**
const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
template solution_value_type<Number>> &
get_values(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
template solution_gradient_type<Number>> &
get_gradients(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
template solution_symmetric_gradient_type<Number>> &
get_symmetric_gradients(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
template solution_divergence_type<Number>> &
get_divergences(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
template solution_curl_type<Number>> &
get_curls(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
template solution_hessian_type<Number>> &
get_hessians(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
template solution_laplacian_type<Number>> &
get_laplacians(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
template solution_third_derivative_type<Number>> &
get_third_derivatives(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/** @} */ // CurrentCellEvaluation
typename FEInterfaceViews::View<dim, spacedim, Extractor>::
template solution_value_type<Number>> &
get_jumps_in_values(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
typename FEInterfaceViews::View<dim, spacedim, Extractor>::
template solution_gradient_type<Number>> &
get_jumps_in_gradients(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
typename FEInterfaceViews::View<dim, spacedim, Extractor>::
template solution_hessian_type<Number>> &
get_jumps_in_hessians(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
typename FEInterfaceViews::View<dim, spacedim, Extractor>::
template solution_third_derivative_type<Number>> &
get_jumps_in_third_derivatives(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/** @} */ // CurrentInterfaceJumpEvaluation
typename FEInterfaceViews::View<dim, spacedim, Extractor>::
template solution_value_type<Number>> &
get_averages_of_values(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
typename FEInterfaceViews::View<dim, spacedim, Extractor>::
template solution_gradient_type<Number>> &
get_averages_of_gradients(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/**
typename FEInterfaceViews::View<dim, spacedim, Extractor>::
template solution_hessian_type<Number>> &
get_averages_of_hessians(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy = Number(0));
/** @} */ // CurrentInterfaceAverageEvaluation
template <typename Extractor, typename Number = double>
std::string
get_unique_name(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const std::string &object_type,
const unsigned int size,
- const Number & exemplar_number) const;
+ const Number &exemplar_number) const;
/**
* Construct a unique name to store local dof values.
std::string
get_unique_dofs_name(const std::string &global_vector_name,
const unsigned int size,
- const Number & exemplar_number) const;
+ const Number &exemplar_number) const;
/**
* @name Data that supports the standard FE implementation
std::string
ScratchData<dim, spacedim>::get_unique_name(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const std::string &object_type,
const unsigned int size,
- const Number & exemplar_number) const
+ const Number &exemplar_number) const
{
return global_vector_name + "_" + variable.get_name() + "_" + object_type +
"_" + Utilities::int_to_string(size) + "_" +
ScratchData<dim, spacedim>::get_unique_dofs_name(
const std::string &global_vector_name,
const unsigned int size,
- const Number & exemplar_number) const
+ const Number &exemplar_number) const
{
return global_vector_name + "_independent_local_dofs_" +
Utilities::int_to_string(size) + "_" +
void
ScratchData<dim, spacedim>::extract_local_dof_values(
const std::string &global_vector_name,
- const VectorType & input_vector,
+ const VectorType &input_vector,
const Number dummy)
{
const unsigned int n_dofs = local_dof_indices.size();
const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
template solution_value_type<Number>> &
ScratchData<dim, spacedim>::get_values(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_gradient_type<Number>> &
ScratchData<dim, spacedim>::get_gradients(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_hessian_type<Number>> &
ScratchData<dim, spacedim>::get_hessians(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_laplacian_type<Number>> &
ScratchData<dim, spacedim>::get_laplacians(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_third_derivative_type<Number>> &
ScratchData<dim, spacedim>::get_third_derivatives(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_symmetric_gradient_type<Number>> &
ScratchData<dim, spacedim>::get_symmetric_gradients(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_divergence_type<Number>> &
ScratchData<dim, spacedim>::get_divergences(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
template solution_curl_type<Number>> &
ScratchData<dim, spacedim>::get_curls(const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_value_type<Number>> &
ScratchData<dim, spacedim>::get_jumps_in_values(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_gradient_type<Number>> &
ScratchData<dim, spacedim>::get_jumps_in_gradients(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_hessian_type<Number>> &
ScratchData<dim, spacedim>::get_jumps_in_hessians(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_third_derivative_type<Number>> &
ScratchData<dim, spacedim>::get_jumps_in_third_derivatives(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_value_type<Number>> &
ScratchData<dim, spacedim>::get_averages_of_values(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_gradient_type<Number>> &
ScratchData<dim, spacedim>::get_averages_of_gradients(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
template solution_hessian_type<Number>> &
ScratchData<dim, spacedim>::get_averages_of_hessians(
const std::string &global_vector_name,
- const Extractor & variable,
+ const Extractor &variable,
const Number dummy)
{
const std::vector<Number> &independent_local_dofs =
* <code>index</code> in the vector #matrix.
*/
void
- assemble(const FullMatrix<double> & M,
+ assemble(const FullMatrix<double> &M,
const unsigned int index,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2);
* Assemble a single matrix into a global matrix.
*/
void
- assemble(MatrixType & G,
- const FullMatrix<double> & M,
+ assemble(MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2);
* Assemble a single matrix into a global matrix.
*/
void
- assemble(MatrixType & G,
- const FullMatrix<double> & M,
+ assemble(MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2,
const unsigned int level);
*/
void
- assemble_up(MatrixType & G,
- const FullMatrix<double> & M,
+ assemble_up(MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2,
const unsigned int level = numbers::invalid_unsigned_int);
*/
void
- assemble_down(MatrixType & G,
- const FullMatrix<double> & M,
+ assemble_down(MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2,
const unsigned int level = numbers::invalid_unsigned_int);
*/
void
- assemble_in(MatrixType & G,
- const FullMatrix<double> & M,
+ assemble_in(MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2,
const unsigned int level = numbers::invalid_unsigned_int);
*/
void
- assemble_out(MatrixType & G,
- const FullMatrix<double> & M,
+ assemble_out(MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2,
const unsigned int level = numbers::invalid_unsigned_int);
* <code>index</code> in the vector #matrix.
*/
void
- assemble(const FullMatrix<double> & M,
- const Vector<double> & vector,
+ assemble(const FullMatrix<double> &M,
+ const Vector<double> &vector,
const unsigned int index,
const std::vector<types::global_dof_index> &indices);
void
- assemble(const FullMatrix<double> & M,
- const Vector<double> & vector,
+ assemble(const FullMatrix<double> &M,
+ const Vector<double> &vector,
const unsigned int index,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2);
template <typename MatrixType>
inline void
MatrixSimple<MatrixType>::assemble(
- const FullMatrix<double> & M,
+ const FullMatrix<double> &M,
const unsigned int index,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2)
template <typename MatrixType>
inline void
MGMatrixSimple<MatrixType>::assemble(
- MatrixType & G,
- const FullMatrix<double> & M,
+ MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2)
{
template <typename MatrixType>
inline void
MGMatrixSimple<MatrixType>::assemble(
- MatrixType & G,
- const FullMatrix<double> & M,
+ MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2,
const unsigned int level)
template <typename MatrixType>
inline void
MGMatrixSimple<MatrixType>::assemble_up(
- MatrixType & G,
- const FullMatrix<double> & M,
+ MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2,
const unsigned int level)
template <typename MatrixType>
inline void
MGMatrixSimple<MatrixType>::assemble_down(
- MatrixType & G,
- const FullMatrix<double> & M,
+ MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2,
const unsigned int level)
template <typename MatrixType>
inline void
MGMatrixSimple<MatrixType>::assemble_in(
- MatrixType & G,
- const FullMatrix<double> & M,
+ MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2,
const unsigned int level)
template <typename MatrixType>
inline void
MGMatrixSimple<MatrixType>::assemble_out(
- MatrixType & G,
- const FullMatrix<double> & M,
+ MatrixType &G,
+ const FullMatrix<double> &M,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2,
const unsigned int level)
template <typename MatrixType, typename VectorType>
inline void
SystemSimple<MatrixType, VectorType>::assemble(
- const FullMatrix<double> & M,
- const Vector<double> & vector,
+ const FullMatrix<double> &M,
+ const Vector<double> &vector,
const unsigned int index,
const std::vector<types::global_dof_index> &indices)
{
template <typename MatrixType, typename VectorType>
inline void
SystemSimple<MatrixType, VectorType>::assemble(
- const FullMatrix<double> & M,
- const Vector<double> & vector,
+ const FullMatrix<double> &M,
+ const Vector<double> &vector,
const unsigned int index,
const std::vector<types::global_dof_index> &i1,
const std::vector<types::global_dof_index> &i2)
std::vector<std::vector<std::vector<Tensor<1, spacedim, Number>>>>
&gradients,
std::vector<std::vector<std::vector<Tensor<2, spacedim, Number>>>>
- & hessians,
- const FEValuesBase<dim, spacedim> & fe,
+ &hessians,
+ const FEValuesBase<dim, spacedim> &fe,
const std::vector<types::global_dof_index> &index,
const unsigned int component,
const unsigned int n_comp,
std::vector<std::vector<std::vector<Tensor<1, spacedim, Number>>>>
&gradients,
std::vector<std::vector<std::vector<Tensor<2, spacedim, Number>>>>
- & hessians,
- const FEValuesBase<dim, spacedim> & fe,
+ &hessians,
+ const FEValuesBase<dim, spacedim> &fe,
const unsigned int level,
const std::vector<types::global_dof_index> &index,
const unsigned int component,
&gradients,
std::vector<std::vector<
std::vector<Tensor<2, spacedim, typename VectorType::value_type>>>>
- & hessians,
- const FEValuesBase<dim, spacedim> & fe,
+ &hessians,
+ const FEValuesBase<dim, spacedim> &fe,
const std::vector<types::global_dof_index> &index,
const unsigned int component,
const unsigned int n_comp,
&gradients,
std::vector<std::vector<
std::vector<Tensor<2, spacedim, typename VectorType::value_type>>>>
- & hessians,
- const FEValuesBase<dim, spacedim> & fe,
+ &hessians,
+ const FEValuesBase<dim, spacedim> &fe,
const unsigned int level,
const std::vector<types::global_dof_index> &index,
const unsigned int component,
template <typename VectorType, int dim, int spacedim>
void
- VectorData<VectorType, dim, spacedim>::initialize(const VectorType * v,
+ VectorData<VectorType, dim, spacedim>::initialize(const VectorType *v,
const std::string &name)
{
SmartPointer<const VectorType, VectorData<VectorType, dim, spacedim>> p = v;
&gradients,
std::vector<std::vector<
std::vector<Tensor<2, spacedim, typename VectorType::value_type>>>>
- & hessians,
- const FEValuesBase<dim, spacedim> & fe,
+ &hessians,
+ const FEValuesBase<dim, spacedim> &fe,
const std::vector<types::global_dof_index> &index,
const unsigned int component,
const unsigned int n_comp,
void
MGVectorData<VectorType, dim, spacedim>::initialize(
const MGLevelObject<VectorType> *v,
- const std::string & name)
+ const std::string &name)
{
SmartPointer<const MGLevelObject<VectorType>,
MGVectorData<VectorType, dim, spacedim>>
&gradients,
std::vector<std::vector<
std::vector<Tensor<2, spacedim, typename VectorType::value_type>>>>
- & hessians,
- const FEValuesBase<dim, spacedim> & fe,
+ &hessians,
+ const FEValuesBase<dim, spacedim> &fe,
const unsigned int level,
const std::vector<types::global_dof_index> &index,
const unsigned int component,
*/
virtual void
vmult(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const = 0;
+ VectorType &dst,
+ const VectorType &src) const = 0;
/**
* Adding matrix-vector-multiplication on a certain level.
*/
virtual void
vmult_add(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const = 0;
+ VectorType &dst,
+ const VectorType &src) const = 0;
/**
* Transpose matrix-vector-multiplication on a certain level.
*/
virtual void
Tvmult(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const = 0;
+ VectorType &dst,
+ const VectorType &src) const = 0;
/**
* Adding transpose matrix-vector-multiplication on a certain level.
*/
virtual void
Tvmult_add(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const = 0;
+ VectorType &dst,
+ const VectorType &src) const = 0;
/**
* Return the minimal level for which matrices are stored.
*/
virtual void
operator()(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const = 0;
+ VectorType &dst,
+ const VectorType &src) const = 0;
};
*/
virtual void
prolongate(const unsigned int to_level,
- VectorType & dst,
- const VectorType & src) const = 0;
+ VectorType &dst,
+ const VectorType &src) const = 0;
/**
* Prolongate a vector from level <tt>to_level-1</tt> to level
*/
virtual void
prolongate_and_add(const unsigned int to_level,
- VectorType & dst,
- const VectorType & src) const;
+ VectorType &dst,
+ const VectorType &src) const;
/**
* Restrict a vector from level <tt>from_level</tt> to level
*/
virtual void
restrict_and_add(const unsigned int from_level,
- VectorType & dst,
- const VectorType & src) const = 0;
+ VectorType &dst,
+ const VectorType &src) const = 0;
};
*/
virtual void
smooth(const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const = 0;
+ VectorType &u,
+ const VectorType &rhs) const = 0;
/**
* As opposed to the smooth() function, this function applies the action of
*/
virtual void
smooth(const unsigned int level,
- BlockVector<number> & u,
+ BlockVector<number> &u,
const BlockVector<number> &rhs) const;
/**
template <typename MGMatrixType, typename MGRelaxationType>
inline void
MGSmootherBlock<MatrixType, RelaxationType, number>::initialize(
- const MGMatrixType & m,
+ const MGMatrixType &m,
const MGRelaxationType &s)
{
const unsigned int min = m.min_level();
inline void
MGSmootherBlock<MatrixType, RelaxationType, number>::smooth(
const unsigned int level,
- BlockVector<number> & u,
+ BlockVector<number> &u,
const BlockVector<number> &rhs) const
{
LogStream::Prefix prefix("Smooth");
*/
void
operator()(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
private:
/**
* Constructor. Only a reference to these objects is stored, so
* their lifetime needs to exceed the usage in this class.
*/
- MGCoarseGridIterativeSolver(SolverType & solver,
- const MatrixType & matrix,
+ MGCoarseGridIterativeSolver(SolverType &solver,
+ const MatrixType &matrix,
const PreconditionerType &precondition);
/**
* details.
*/
void
- initialize(SolverType & solver,
- const MatrixType & matrix,
+ initialize(SolverType &solver,
+ const MatrixType &matrix,
const PreconditionerType &precondition);
/**
*/
virtual void
operator()(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
private:
/**
void
operator()(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
private:
/**
void
operator()(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const;
+ VectorType &dst,
+ const VectorType &src) const;
/**
* Write the singular values to @p deallog.
template <typename VectorType>
void
MGCoarseGridApplySmoother<VectorType>::operator()(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const
+ VectorType &dst,
+ const VectorType &src) const
{
coarse_smooth->apply(level, dst, src);
}
SolverType,
MatrixType,
PreconditionerType>::
- MGCoarseGridIterativeSolver(SolverType & solver,
- const MatrixType & matrix,
+ MGCoarseGridIterativeSolver(SolverType &solver,
+ const MatrixType &matrix,
const PreconditionerType &preconditioner)
: solver(&solver, typeid(*this).name())
, matrix(&matrix, typeid(*this).name())
VectorType,
SolverType,
MatrixType,
- PreconditionerType>::initialize(SolverType & solver_,
- const MatrixType & matrix_,
+ PreconditionerType>::initialize(SolverType &solver_,
+ const MatrixType &matrix_,
const PreconditionerType &preconditioner_)
{
solver = &solver_;
std::is_same_v<VectorType, typename SolverType::vector_type>,
VectorType> * = nullptr>
void
- solve(SolverType & solver,
- const MatrixType & matrix,
+ solve(SolverType &solver,
+ const MatrixType &matrix,
const PreconditionerType &preconditioner,
- VectorType & dst,
- const VectorType & src)
+ VectorType &dst,
+ const VectorType &src)
{
solver.solve(matrix, dst, src, preconditioner);
}
!std::is_same_v<VectorType, typename SolverType::vector_type>,
VectorType> * = nullptr>
void
- solve(SolverType & solver,
- const MatrixType & matrix,
+ solve(SolverType &solver,
+ const MatrixType &matrix,
const PreconditionerType &preconditioner,
- VectorType & dst,
- const VectorType & src)
+ VectorType &dst,
+ const VectorType &src)
{
typename SolverType::vector_type src_;
typename SolverType::vector_type dst_;
typename MatrixType,
typename PreconditionerType>
void
- MGCoarseGridIterativeSolver<
- VectorType,
- SolverType,
- MatrixType,
- PreconditionerType>::operator()(const unsigned int /*level*/,
- VectorType & dst,
+MGCoarseGridIterativeSolver<
+ VectorType,
+ SolverType,
+ MatrixType,
+ PreconditionerType>::operator()(const unsigned int /*level*/,
+ VectorType &dst,
const VectorType &src) const
{
Assert(solver != nullptr, ExcNotInitialized());
void
MGCoarseGridHouseholder<number, VectorType>::operator()(
const unsigned int /*level*/,
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
householder.least_squares(dst, src);
template <typename number, typename VectorType>
void
MGCoarseGridSVD<number, VectorType>::operator()(const unsigned int /*level*/,
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
matrix.vmult(dst, src);
template <int dim, int spacedim>
void
initialize(const DoFHandler<dim, spacedim> &dof,
- const MGLevelObject<IndexSet> & level_relevant_dofs =
+ const MGLevelObject<IndexSet> &level_relevant_dofs =
MGLevelObject<IndexSet>());
/**
template <int dim, int spacedim>
void
make_zero_boundary_constraints(
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const std::set<types::boundary_id> &boundary_ids,
- const ComponentMask & component_mask = {});
+ const ComponentMask &component_mask = {});
/**
* Add Dirichlet boundary dofs to the internal data structures
void
add_boundary_indices(const DoFHandler<dim, spacedim> &dof,
const unsigned int level,
- const IndexSet & boundary_indices);
+ const IndexSet &boundary_indices);
/**
* Add user defined constraints to be used on level @p level.
inline void
MGConstrainedDoFs::initialize(
const DoFHandler<dim, spacedim> &dof,
- const MGLevelObject<IndexSet> & level_relevant_dofs)
+ const MGLevelObject<IndexSet> &level_relevant_dofs)
{
boundary_indices.clear();
refinement_edge_indices.clear();
template <int dim, int spacedim>
inline void
MGConstrainedDoFs::make_zero_boundary_constraints(
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const std::set<types::boundary_id> &boundary_ids,
- const ComponentMask & component_mask)
+ const ComponentMask &component_mask)
{
// allocate an IndexSet for each global level. Contents will be
// overwritten inside make_boundary_list.
virtual void
vmult(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
virtual void
vmult_add(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
virtual void
Tvmult(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
virtual void
Tvmult_add(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
virtual unsigned int
get_minlevel() const override;
virtual unsigned int
*/
virtual void
vmult(const unsigned int level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const;
/**
*/
virtual void
vmult_add(const unsigned int level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const;
/**
*/
virtual void
Tvmult(const unsigned int level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const;
/**
*/
virtual void
Tvmult_add(const unsigned int level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const;
private:
template <typename VectorType>
void
Matrix<VectorType>::vmult(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const
+ VectorType &dst,
+ const VectorType &src) const
{
matrices[level].vmult(dst, src);
}
template <typename VectorType>
void
Matrix<VectorType>::vmult_add(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const
+ VectorType &dst,
+ const VectorType &src) const
{
matrices[level].vmult_add(dst, src);
}
template <typename VectorType>
void
Matrix<VectorType>::Tvmult(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const
+ VectorType &dst,
+ const VectorType &src) const
{
matrices[level].Tvmult(dst, src);
}
template <typename VectorType>
void
Matrix<VectorType>::Tvmult_add(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const
+ VectorType &dst,
+ const VectorType &src) const
{
matrices[level].Tvmult_add(dst, src);
}
template <typename MatrixType, typename number>
void
MGMatrixSelect<MatrixType, number>::vmult(const unsigned int level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const
{
Assert(matrix != 0, ExcNotInitialized());
template <typename MatrixType, typename number>
void
MGMatrixSelect<MatrixType, number>::vmult_add(const unsigned int level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const
{
Assert(matrix != 0, ExcNotInitialized());
template <typename MatrixType, typename number>
void
MGMatrixSelect<MatrixType, number>::Tvmult(const unsigned int level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const
{
Assert(matrix != 0, ExcNotInitialized());
template <typename MatrixType, typename number>
void
MGMatrixSelect<MatrixType, number>::Tvmult_add(const unsigned int level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const
{
Assert(matrix != 0, ExcNotInitialized());
*/
template <typename MatrixType2>
void
- initialize(const MGLevelObject<MatrixType2> & matrices,
+ initialize(const MGLevelObject<MatrixType2> &matrices,
const typename RelaxationType::AdditionalData &additional_data =
typename RelaxationType::AdditionalData());
template <typename MatrixType2, typename DataType>
void
initialize(const MGLevelObject<MatrixType2> &matrices,
- const MGLevelObject<DataType> & additional_data);
+ const MGLevelObject<DataType> &additional_data);
/**
* Empty all vectors.
*/
virtual void
smooth(const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const override;
+ VectorType &u,
+ const VectorType &rhs) const override;
/**
* The apply variant of smoothing, setting the vector u to zero before
*/
virtual void
apply(const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const override;
+ VectorType &u,
+ const VectorType &rhs) const override;
/**
* Memory used by this object.
*/
template <typename MatrixType2>
void
- initialize(const MGLevelObject<MatrixType2> & matrices,
+ initialize(const MGLevelObject<MatrixType2> &matrices,
const typename RelaxationType::AdditionalData &additional_data =
typename RelaxationType::AdditionalData());
template <typename MatrixType2, typename DataType>
void
initialize(const MGLevelObject<MatrixType2> &matrices,
- const MGLevelObject<DataType> & additional_data);
+ const MGLevelObject<DataType> &additional_data);
/**
* Initialize for single blocks of matrices. Of this block matrix, the block
template <typename MatrixType2, typename DataType>
void
initialize(const MGLevelObject<MatrixType2> &matrices,
- const DataType & additional_data,
+ const DataType &additional_data,
const unsigned int block_row,
const unsigned int block_col);
template <typename MatrixType2, typename DataType>
void
initialize(const MGLevelObject<MatrixType2> &matrices,
- const MGLevelObject<DataType> & additional_data,
+ const MGLevelObject<DataType> &additional_data,
const unsigned int block_row,
const unsigned int block_col);
template <typename MatrixType2, typename DataType>
void
initialize(const MGLevelObject<MatrixType2> &matrices,
- const MGLevelObject<DataType> & additional_data);
+ const MGLevelObject<DataType> &additional_data);
/**
* Initialize for single blocks of matrices. Of this block matrix, the block
template <typename MatrixType2, typename DataType>
void
initialize(const MGLevelObject<MatrixType2> &matrices,
- const DataType & additional_data,
+ const DataType &additional_data,
const unsigned int block_row,
const unsigned int block_col);
template <typename MatrixType2, typename DataType>
void
initialize(const MGLevelObject<MatrixType2> &matrices,
- const MGLevelObject<DataType> & additional_data,
+ const MGLevelObject<DataType> &additional_data,
const unsigned int block_row,
const unsigned int block_col);
*/
virtual void
smooth(const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const override;
+ VectorType &u,
+ const VectorType &rhs) const override;
/**
* The apply variant of smoothing, setting the vector u to zero before
*/
virtual void
apply(const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const override;
+ VectorType &u,
+ const VectorType &rhs) const override;
/**
* Object containing relaxation methods.
template <typename MatrixType2>
inline void
SmootherRelaxation<RelaxationType, VectorType>::initialize(
- const MGLevelObject<MatrixType2> & m,
+ const MGLevelObject<MatrixType2> &m,
const typename RelaxationType::AdditionalData &data)
{
const unsigned int min = m.min_level();
inline void
SmootherRelaxation<RelaxationType, VectorType>::initialize(
const MGLevelObject<MatrixType2> &m,
- const MGLevelObject<DataType> & data)
+ const MGLevelObject<DataType> &data)
{
const unsigned int min = std::max(m.min_level(), data.min_level());
const unsigned int max = std::min(m.max_level(), data.max_level());
inline void
SmootherRelaxation<RelaxationType, VectorType>::smooth(
const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const
+ VectorType &u,
+ const VectorType &rhs) const
{
unsigned int maxlevel = this->max_level();
unsigned int steps2 = this->steps;
inline void
SmootherRelaxation<RelaxationType, VectorType>::apply(
const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const
+ VectorType &u,
+ const VectorType &rhs) const
{
unsigned int maxlevel = this->max_level();
unsigned int steps2 = this->steps;
template <typename MatrixType2>
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize(
- const MGLevelObject<MatrixType2> & m,
+ const MGLevelObject<MatrixType2> &m,
const typename RelaxationType::AdditionalData &data)
{
const unsigned int min = m.min_level();
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize(
const MGLevelObject<MatrixType2> &m,
- const MGLevelObject<DataType> & data)
+ const MGLevelObject<DataType> &data)
{
const unsigned int min = m.min_level();
const unsigned int max = m.max_level();
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize(
const MGLevelObject<MatrixType2> &m,
- const DataType & data,
+ const DataType &data,
const unsigned int row,
const unsigned int col)
{
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize(
const MGLevelObject<MatrixType2> &m,
- const MGLevelObject<DataType> & data,
+ const MGLevelObject<DataType> &data,
const unsigned int row,
const unsigned int col)
{
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::smooth(
const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const
+ VectorType &u,
+ const VectorType &rhs) const
{
unsigned int maxlevel = smoothers.max_level();
unsigned int steps2 = this->steps;
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::apply(
const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const
+ VectorType &u,
+ const VectorType &rhs) const
{
unsigned int maxlevel = smoothers.max_level();
unsigned int steps2 = this->steps;
template <typename MatrixType2>
inline void
MGSmootherPrecondition<MatrixType, PreconditionerType, VectorType>::initialize(
- const MGLevelObject<MatrixType2> & m,
+ const MGLevelObject<MatrixType2> &m,
const typename PreconditionerType::AdditionalData &data)
{
const unsigned int min = m.min_level();
inline void
MGSmootherPrecondition<MatrixType, PreconditionerType, VectorType>::initialize(
const MGLevelObject<MatrixType2> &m,
- const MGLevelObject<DataType> & data)
+ const MGLevelObject<DataType> &data)
{
const unsigned int min = m.min_level();
const unsigned int max = m.max_level();
inline void
MGSmootherPrecondition<MatrixType, PreconditionerType, VectorType>::initialize(
const MGLevelObject<MatrixType2> &m,
- const DataType & data,
+ const DataType &data,
const unsigned int row,
const unsigned int col)
{
inline void
MGSmootherPrecondition<MatrixType, PreconditionerType, VectorType>::initialize(
const MGLevelObject<MatrixType2> &m,
- const MGLevelObject<DataType> & data,
+ const MGLevelObject<DataType> &data,
const unsigned int row,
const unsigned int col)
{
inline void
MGSmootherPrecondition<MatrixType, PreconditionerType, VectorType>::smooth(
const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const
+ VectorType &u,
+ const VectorType &rhs) const
{
unsigned int maxlevel = matrices.max_level();
unsigned int steps2 = this->steps;
inline void
MGSmootherPrecondition<MatrixType, PreconditionerType, VectorType>::apply(
const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const
+ VectorType &u,
+ const VectorType &rhs) const
{
unsigned int maxlevel = matrices.max_level();
unsigned int steps2 = this->steps;
compute_row_length_vector(
const DoFHandler<dim, spacedim> &dofs,
const unsigned int level,
- std::vector<unsigned int> & row_lengths,
+ std::vector<unsigned int> &row_lengths,
const DoFTools::Coupling flux_couplings = DoFTools::none);
/**
*/
template <int dim, int spacedim>
void
- compute_row_length_vector(const DoFHandler<dim, spacedim> & dofs,
+ compute_row_length_vector(const DoFHandler<dim, spacedim> &dofs,
const unsigned int level,
- std::vector<unsigned int> & row_lengths,
+ std::vector<unsigned int> &row_lengths,
const Table<2, DoFTools::Coupling> &couplings,
const Table<2, DoFTools::Coupling> &flux_couplings);
template <int dim, int spacedim, typename number = double>
void
make_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_handler,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const unsigned int level,
const AffineConstraints<number> &constraints = {},
const bool keep_constrained_dofs = true);
template <int dim, int spacedim, typename number = double>
void
make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_handler,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const unsigned int level,
const AffineConstraints<number> &constraints = {},
const bool keep_constrained_dofs = true);
template <int dim, int spacedim>
void
make_flux_sparsity_pattern_edge(const DoFHandler<dim, spacedim> &dof_handler,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const unsigned int level);
/**
* This function does the same as the other with the same name, but it gets
*/
template <int dim, int spacedim>
void
- make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> & dof,
- SparsityPatternBase & sparsity,
+ make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
+ SparsityPatternBase &sparsity,
const unsigned int level,
const Table<2, DoFTools::Coupling> &int_mask,
const Table<2, DoFTools::Coupling> &flux_mask);
template <int dim, int spacedim>
void
make_flux_sparsity_pattern_edge(
- const DoFHandler<dim, spacedim> & dof_handler,
- SparsityPatternBase & sparsity,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ SparsityPatternBase &sparsity,
const unsigned int level,
const Table<2, DoFTools::Coupling> &flux_mask);
void
make_interface_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_handler,
const MGConstrainedDoFs &mg_constrained_dofs,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const unsigned int level);
template <int dim, int spacedim>
void
count_dofs_per_block(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
std::vector<std::vector<types::global_dof_index>> &dofs_per_block,
std::vector<unsigned int> target_block = {});
template <int dim, int spacedim>
void
count_dofs_per_component(
- const DoFHandler<dim, spacedim> & mg_dof,
+ const DoFHandler<dim, spacedim> &mg_dof,
std::vector<std::vector<types::global_dof_index>> &result,
const bool only_once = false,
std::vector<unsigned int> target_component = {});
make_boundary_list(
const DoFHandler<dim, spacedim> &mg_dof,
const std::map<types::boundary_id, const Function<spacedim> *>
- & function_map,
+ &function_map,
std::vector<std::set<types::global_dof_index>> &boundary_indices,
- const ComponentMask & component_mask = {});
+ const ComponentMask &component_mask = {});
/**
* The same function as above, but return an IndexSet rather than a
*/
template <int dim, int spacedim>
void
- make_boundary_list(const DoFHandler<dim, spacedim> & mg_dof,
+ make_boundary_list(const DoFHandler<dim, spacedim> &mg_dof,
const std::map<types::boundary_id,
const Function<spacedim> *> &function_map,
std::vector<IndexSet> &boundary_indices,
- const ComponentMask & component_mask = {});
+ const ComponentMask &component_mask = {});
/**
* The same function as above, but return an IndexSet rather than a
*/
template <int dim, int spacedim>
void
- make_boundary_list(const DoFHandler<dim, spacedim> & mg_dof,
+ make_boundary_list(const DoFHandler<dim, spacedim> &mg_dof,
const std::set<types::boundary_id> &boundary_ids,
- std::vector<IndexSet> & boundary_indices,
- const ComponentMask & component_mask = {});
+ std::vector<IndexSet> &boundary_indices,
+ const ComponentMask &component_mask = {});
/**
* For each level in a multigrid hierarchy, produce an IndexSet that
template <int dim, int spacedim>
void
extract_inner_interface_dofs(const DoFHandler<dim, spacedim> &mg_dof_handler,
- std::vector<IndexSet> & interface_dofs);
+ std::vector<IndexSet> &interface_dofs);
/**
* Return the highest possible level that can be used as the coarsest level in
template <typename SparsityPatternType, int dim, int spacedim>
static void
- reinit(Matrix & matrix,
- Sparsity & sparsity,
+ reinit(Matrix &matrix,
+ Sparsity &sparsity,
int level,
const SparsityPatternType &sp,
const DoFHandler<dim, spacedim> &)
reinit(Matrix &matrix,
Sparsity &,
int level,
- const SparsityPatternType & sp,
+ const SparsityPatternType &sp,
const DoFHandler<dim, spacedim> &dh)
{
const MPI_Comm communicator = dh.get_communicator();
reinit(Matrix &matrix,
Sparsity &,
int level,
- const SparsityPatternType & sp,
+ const SparsityPatternType &sp,
const DoFHandler<dim, spacedim> &dh)
{
const MPI_Comm communicator = dh.get_communicator();
reinit(Matrix &matrix,
Sparsity &,
int level,
- const SparsityPatternType & sp,
+ const SparsityPatternType &sp,
const DoFHandler<dim, spacedim> &dh)
{
const MPI_Comm communicator = dh.get_communicator();
reinit(Matrix &matrix,
Sparsity &,
int level,
- const SparsityPatternType & sp,
+ const SparsityPatternType &sp,
const DoFHandler<dim, spacedim> &dh)
{
const MPI_Comm communicator = dh.get_communicator();
reinit(Matrix &matrix,
Sparsity &,
int level,
- const SparsityPatternType & sp,
+ const SparsityPatternType &sp,
const DoFHandler<dim, spacedim> &dh)
{
const MPI_Comm communicator = dh.get_communicator();
template <int dim, class InVector, int spacedim>
void
copy_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
- MGLevelObject<VectorType> & dst,
- const InVector & src) const;
+ MGLevelObject<VectorType> &dst,
+ const InVector &src) const;
/**
* Transfer from multi-level vector to normal vector.
template <int dim, class OutVector, int spacedim>
void
copy_from_mg(const DoFHandler<dim, spacedim> &dof_handler,
- OutVector & dst,
+ OutVector &dst,
const MGLevelObject<VectorType> &src) const;
/**
template <int dim, class OutVector, int spacedim>
void
copy_from_mg_add(const DoFHandler<dim, spacedim> &dof_handler,
- OutVector & dst,
+ OutVector &dst,
const MGLevelObject<VectorType> &src) const;
/**
template <int dim, typename Number2, int spacedim>
void
copy_from_mg(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
LinearAlgebra::distributed::Vector<Number2> &dst,
const MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &src) const;
template <int dim, typename Number2, int spacedim>
void
copy_from_mg_add(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
LinearAlgebra::distributed::Vector<Number2> &dst,
const MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &src) const;
void
copy_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &dst,
- const LinearAlgebra::distributed::Vector<Number2> & src,
+ const LinearAlgebra::distributed::Vector<Number2> &src,
const bool solution_transfer) const;
/**
*/
virtual void
prolongate(const unsigned int to_level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
/**
* Restrict a vector from level <tt>from_level</tt> to level
*/
virtual void
restrict_and_add(const unsigned int from_level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
/**
* Finite element does not provide prolongation matrices.
#include <algorithm>
// Here you can turn on some cout statements and MPI Barriers for debugging:
-//#define DEBUG_OUTPUT
+// #define DEBUG_OUTPUT
DEAL_II_NAMESPACE_OPEN
*/
template <int dim, typename number, int spacedim>
void
- reinit_vector(const DoFHandler<dim, spacedim> & dof_handler,
+ reinit_vector(const DoFHandler<dim, spacedim> &dof_handler,
std::vector<unsigned int> target_component,
MGLevelObject<BlockVector<number>> &v)
{
void
copy_vector(const std::vector<
std::pair<types::global_dof_index, types::global_dof_index>>
- & copy_indices,
+ ©_indices,
const T &src,
- V & dst)
+ V &dst)
{
// we should have copy_index.second == copy_index.first, therefore we can
// use the same function for both copying to mg as well as copying from mg
copy_vector(const std::vector<
std::pair<types::global_dof_index, types::global_dof_index>> &,
const T &src,
- T & dst)
+ T &dst)
{
dst = src;
}
void
MGLevelGlobalTransfer<VectorType>::copy_to_mg(
const DoFHandler<dim, spacedim> &dof_handler,
- MGLevelObject<VectorType> & dst,
- const InVector & src) const
+ MGLevelObject<VectorType> &dst,
+ const InVector &src) const
{
assert_built(dof_handler);
AssertIndexRange(dst.max_level(),
void
MGLevelGlobalTransfer<VectorType>::copy_from_mg(
const DoFHandler<dim, spacedim> &dof_handler,
- OutVector & dst,
+ OutVector &dst,
const MGLevelObject<VectorType> &src) const
{
assert_built(dof_handler);
void
MGLevelGlobalTransfer<VectorType>::copy_from_mg_add(
const DoFHandler<dim, spacedim> &dof_handler,
- OutVector & dst,
+ OutVector &dst,
const MGLevelObject<VectorType> &src) const
{
assert_built(dof_handler);
template <int dim, typename Number2, int spacedim>
void
MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::copy_to_mg(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &dst,
- const LinearAlgebra::distributed::Vector<Number2> & src) const
+ const LinearAlgebra::distributed::Vector<Number2> &src) const
{
assert_built(dof_handler);
copy_to_mg(dof_handler, dst, src, false);
template <int dim, typename Number2, int spacedim>
void
MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::copy_to_mg(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &dst,
- const LinearAlgebra::distributed::Vector<Number2> & src,
+ const LinearAlgebra::distributed::Vector<Number2> &src,
const bool solution_transfer) const
{
assert_built(dof_handler);
template <int dim, typename Number2, int spacedim>
void
MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::copy_from_mg(
- const DoFHandler<dim, spacedim> & dof_handler,
- LinearAlgebra::distributed::Vector<Number2> & dst,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ LinearAlgebra::distributed::Vector<Number2> &dst,
const MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &src) const
{
assert_built(dof_handler);
void
MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::
copy_from_mg_add(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
LinearAlgebra::distributed::Vector<Number2> &dst,
const MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &src) const
{
* blocks is to be weighted differently.
*/
void
- initialize(const std::vector<number> & factors,
+ initialize(const std::vector<number> &factors,
VectorMemory<Vector<number>> &memory);
/**
template <int dim, int spacedim>
void
build(const DoFHandler<dim, spacedim> &dof_handler,
- const std::vector<bool> & selected);
+ const std::vector<bool> &selected);
virtual void
prolongate(const unsigned int to_level,
- BlockVector<number> & dst,
+ BlockVector<number> &dst,
const BlockVector<number> &src) const override;
virtual void
restrict_and_add(const unsigned int from_level,
- BlockVector<number> & dst,
+ BlockVector<number> &dst,
const BlockVector<number> &src) const override;
/**
*/
template <int dim, typename number2, int spacedim>
void
- copy_to_mg(const DoFHandler<dim, spacedim> & dof_handler,
+ copy_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
MGLevelObject<BlockVector<number>> &dst,
- const BlockVector<number2> & src) const;
+ const BlockVector<number2> &src) const;
/**
* Transfer from multi-level vector to normal vector.
*/
template <int dim, typename number2, int spacedim>
void
- copy_from_mg(const DoFHandler<dim, spacedim> & dof_handler,
- BlockVector<number2> & dst,
+ copy_from_mg(const DoFHandler<dim, spacedim> &dof_handler,
+ BlockVector<number2> &dst,
const MGLevelObject<BlockVector<number>> &src) const;
/**
*/
template <int dim, typename number2, int spacedim>
void
- copy_from_mg_add(const DoFHandler<dim, spacedim> & dof_handler,
- BlockVector<number2> & dst,
+ copy_from_mg_add(const DoFHandler<dim, spacedim> &dof_handler,
+ BlockVector<number2> &dst,
const MGLevelObject<BlockVector<number>> &src) const;
using MGTransferBlockBase::memory_consumption;
virtual void
prolongate(const unsigned int to_level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const override;
virtual void
restrict_and_add(const unsigned int from_level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const override;
/**
template <int dim, typename number2, int spacedim>
void
copy_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
- MGLevelObject<Vector<number>> & dst,
- const Vector<number2> & src) const;
+ MGLevelObject<Vector<number>> &dst,
+ const Vector<number2> &src) const;
/**
* Transfer from multilevel vector to normal vector.
*/
template <int dim, typename number2, int spacedim>
void
- copy_from_mg(const DoFHandler<dim, spacedim> & dof_handler,
- Vector<number2> & dst,
+ copy_from_mg(const DoFHandler<dim, spacedim> &dof_handler,
+ Vector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const;
/**
*/
template <int dim, typename number2, int spacedim>
void
- copy_from_mg_add(const DoFHandler<dim, spacedim> & dof_handler,
- Vector<number2> & dst,
+ copy_from_mg_add(const DoFHandler<dim, spacedim> &dof_handler,
+ Vector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const;
/**
template <int dim, typename number2, int spacedim>
void
copy_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
- MGLevelObject<Vector<number>> & dst,
- const BlockVector<number2> & src) const;
+ MGLevelObject<Vector<number>> &dst,
+ const BlockVector<number2> &src) const;
/**
* Transfer from multilevel vector to normal vector.
*/
template <int dim, typename number2, int spacedim>
void
- copy_from_mg(const DoFHandler<dim, spacedim> & dof_handler,
- BlockVector<number2> & dst,
+ copy_from_mg(const DoFHandler<dim, spacedim> &dof_handler,
+ BlockVector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const;
/**
*/
template <int dim, typename number2, int spacedim>
void
- copy_from_mg_add(const DoFHandler<dim, spacedim> & dof_handler,
- BlockVector<number2> & dst,
+ copy_from_mg_add(const DoFHandler<dim, spacedim> &dof_handler,
+ BlockVector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const;
/**
*/
template <int dim, class OutVector, int spacedim>
void
- do_copy_from_mg(const DoFHandler<dim, spacedim> & dof_handler,
- OutVector & dst,
+ do_copy_from_mg(const DoFHandler<dim, spacedim> &dof_handler,
+ OutVector &dst,
const MGLevelObject<Vector<number>> &src,
const unsigned int offset) const;
*/
template <int dim, class OutVector, int spacedim>
void
- do_copy_from_mg_add(const DoFHandler<dim, spacedim> & dof_handler,
- OutVector & dst,
+ do_copy_from_mg_add(const DoFHandler<dim, spacedim> &dof_handler,
+ OutVector &dst,
const MGLevelObject<Vector<number>> &src,
const unsigned int offset) const;
template <int dim, class InVector, int spacedim>
void
do_copy_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
- MGLevelObject<Vector<number>> & dst,
- const InVector & src,
+ MGLevelObject<Vector<number>> &dst,
+ const InVector &src,
const unsigned int offset) const;
/**
* Selected block.
template <int dim, typename number2, int spacedim>
void
MGTransferBlockSelect<number>::copy_from_mg(
- const DoFHandler<dim, spacedim> & dof_handler,
- BlockVector<number2> & dst,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ BlockVector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const
{
for (unsigned int level = 0;
template <int dim, typename number2, int spacedim>
void
MGTransferBlockSelect<number>::copy_from_mg(
- const DoFHandler<dim, spacedim> & dof_handler,
- Vector<number2> & dst,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ Vector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const
{
for (unsigned int level = 0;
template <int dim, typename number2, int spacedim>
void
MGTransferBlockSelect<number>::copy_from_mg_add(
- const DoFHandler<dim, spacedim> & dof_handler,
- BlockVector<number2> & dst,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ BlockVector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const
{
for (unsigned int level = 0;
template <int dim, typename number2, int spacedim>
void
MGTransferBlockSelect<number>::copy_from_mg_add(
- const DoFHandler<dim, spacedim> & dof_handler,
- Vector<number2> & dst,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ Vector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const
{
for (unsigned int level = 0;
template <int dim, typename number2, int spacedim>
void
MGTransferBlock<number>::copy_from_mg(
- const DoFHandler<dim, spacedim> & dof_handler,
- BlockVector<number2> & dst,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ BlockVector<number2> &dst,
const MGLevelObject<BlockVector<number>> &src) const
{
for (unsigned int block = 0; block < selected.size(); ++block)
template <int dim, typename number2, int spacedim>
void
MGTransferBlock<number>::copy_from_mg_add(
- const DoFHandler<dim, spacedim> & dof_handler,
- BlockVector<number2> & dst,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ BlockVector<number2> &dst,
const MGLevelObject<BlockVector<number>> &src) const
{
for (unsigned int block = 0; block < selected.size(); ++block)
virtual void
prolongate(const unsigned int to_level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const override;
virtual void
restrict_and_add(const unsigned int from_level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const override;
/**
template <int dim, typename number2, int spacedim>
void
copy_to_mg(const DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<Vector<number>> & dst,
- const Vector<number2> & src) const;
+ MGLevelObject<Vector<number>> &dst,
+ const Vector<number2> &src) const;
/**
* Transfer from multilevel vector to normal vector.
*/
template <int dim, typename number2, int spacedim>
void
- copy_from_mg(const DoFHandler<dim, spacedim> & mg_dof,
- Vector<number2> & dst,
+ copy_from_mg(const DoFHandler<dim, spacedim> &mg_dof,
+ Vector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const;
/**
*/
template <int dim, typename number2, int spacedim>
void
- copy_from_mg_add(const DoFHandler<dim, spacedim> & mg_dof,
- Vector<number2> & dst,
+ copy_from_mg_add(const DoFHandler<dim, spacedim> &mg_dof,
+ Vector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const;
/**
template <int dim, typename number2, int spacedim>
void
copy_to_mg(const DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<Vector<number>> & dst,
- const BlockVector<number2> & src) const;
+ MGLevelObject<Vector<number>> &dst,
+ const BlockVector<number2> &src) const;
/**
* Transfer from multilevel vector to normal vector.
*/
template <int dim, typename number2, int spacedim>
void
- copy_from_mg(const DoFHandler<dim, spacedim> & mg_dof,
- BlockVector<number2> & dst,
+ copy_from_mg(const DoFHandler<dim, spacedim> &mg_dof,
+ BlockVector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const;
/**
*/
template <int dim, typename number2, int spacedim>
void
- copy_from_mg_add(const DoFHandler<dim, spacedim> & mg_dof,
- BlockVector<number2> & dst,
+ copy_from_mg_add(const DoFHandler<dim, spacedim> &mg_dof,
+ BlockVector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const;
/**
*/
template <int dim, class OutVector, int spacedim>
void
- do_copy_from_mg(const DoFHandler<dim, spacedim> & mg_dof,
- OutVector & dst,
+ do_copy_from_mg(const DoFHandler<dim, spacedim> &mg_dof,
+ OutVector &dst,
const MGLevelObject<Vector<number>> &src) const;
/**
*/
template <int dim, class OutVector, int spacedim>
void
- do_copy_from_mg_add(const DoFHandler<dim, spacedim> & mg_dof,
- OutVector & dst,
+ do_copy_from_mg_add(const DoFHandler<dim, spacedim> &mg_dof,
+ OutVector &dst,
const MGLevelObject<Vector<number>> &src) const;
/**
template <int dim, class InVector, int spacedim>
void
do_copy_to_mg(const DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<Vector<number>> & dst,
- const InVector & src) const;
+ MGLevelObject<Vector<number>> &dst,
+ const InVector &src) const;
/**
* Selected component of global vector.
*/
void
MGTransferSelect<number>::copy_to_mg(
const DoFHandler<dim, spacedim> &mg_dof_handler,
- MGLevelObject<Vector<number>> & dst,
- const BlockVector<number2> & src) const
+ MGLevelObject<Vector<number>> &dst,
+ const BlockVector<number2> &src) const
{
do_copy_to_mg(mg_dof_handler,
dst,
void
MGTransferSelect<number>::copy_to_mg(
const DoFHandler<dim, spacedim> &mg_dof_handler,
- MGLevelObject<Vector<number>> & dst,
- const Vector<number2> & src) const
+ MGLevelObject<Vector<number>> &dst,
+ const Vector<number2> &src) const
{
do_copy_to_mg(mg_dof_handler, dst, src);
}
template <int dim, typename number2, int spacedim>
void
MGTransferSelect<number>::copy_from_mg(
- const DoFHandler<dim, spacedim> & mg_dof_handler,
- BlockVector<number2> & dst,
+ const DoFHandler<dim, spacedim> &mg_dof_handler,
+ BlockVector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const
{
dst = 0;
template <int dim, typename number2, int spacedim>
void
MGTransferSelect<number>::copy_from_mg(
- const DoFHandler<dim, spacedim> & mg_dof_handler,
- Vector<number2> & dst,
+ const DoFHandler<dim, spacedim> &mg_dof_handler,
+ Vector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const
{
dst = 0;
template <int dim, typename number2, int spacedim>
void
MGTransferSelect<number>::copy_from_mg_add(
- const DoFHandler<dim, spacedim> & mg_dof_handler,
- BlockVector<number2> & dst,
+ const DoFHandler<dim, spacedim> &mg_dof_handler,
+ BlockVector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const
{
do_copy_from_mg_add(mg_dof_handler, dst, src);
template <int dim, typename number2, int spacedim>
void
MGTransferSelect<number>::copy_from_mg_add(
- const DoFHandler<dim, spacedim> & mg_dof_handler,
- Vector<number2> & dst,
+ const DoFHandler<dim, spacedim> &mg_dof_handler,
+ Vector<number2> &dst,
const MGLevelObject<Vector<number>> &src) const
{
do_copy_from_mg_add(mg_dof_handler, dst, src);
template <int dim, class OutVector, int spacedim>
void
MGTransferSelect<number>::do_copy_from_mg(
- const DoFHandler<dim, spacedim> & mg_dof_handler,
- OutVector & dst,
+ const DoFHandler<dim, spacedim> &mg_dof_handler,
+ OutVector &dst,
const MGLevelObject<Vector<number>> &src) const
{
typename DoFHandler<dim, spacedim>::active_cell_iterator level_cell =
template <int dim, class OutVector, int spacedim>
void
MGTransferSelect<number>::do_copy_from_mg_add(
- const DoFHandler<dim, spacedim> & mg_dof_handler,
- OutVector & dst,
+ const DoFHandler<dim, spacedim> &mg_dof_handler,
+ OutVector &dst,
const MGLevelObject<Vector<number>> &src) const
{
typename DoFHandler<dim, spacedim>::active_cell_iterator level_cell =
template <int dim, int spacedim>
std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
create_geometric_coarsening_sequence(
- Triangulation<dim, spacedim> & tria,
+ Triangulation<dim, spacedim> &tria,
const RepartitioningPolicyTools::Base<dim, spacedim> &policy,
const bool preserve_fine_triangulation,
const bool repartition_fine_triangulation);
template <int dim, int spacedim>
std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
create_geometric_coarsening_sequence(
- const Triangulation<dim, spacedim> & tria,
+ const Triangulation<dim, spacedim> &tria,
const RepartitioningPolicyTools::Base<dim, spacedim> &policy,
const bool repartition_fine_triangulation = false);
*/
virtual void
prolongate_and_add_internal(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const = 0;
/**
*/
virtual void
restrict_and_add_internal(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const = 0;
/**
internal::MatrixFreeFunctions::ConstraintInfo<
dim,
VectorizedArray<Number, width>> &constraint_info_coarse,
- std::vector<unsigned int> & dof_indices_fine);
+ std::vector<unsigned int> &dof_indices_fine);
/**
* Flag if the finite elements on the fine cells are continuous. If yes,
*/
void
reinit_geometric_transfer(
- const DoFHandler<dim> & dof_handler_fine,
- const DoFHandler<dim> & dof_handler_coarse,
+ const DoFHandler<dim> &dof_handler_fine,
+ const DoFHandler<dim> &dof_handler_coarse,
const AffineConstraints<Number> &constraint_fine =
AffineConstraints<Number>(),
const AffineConstraints<Number> &constraint_coarse =
*/
void
reinit_polynomial_transfer(
- const DoFHandler<dim> & dof_handler_fine,
- const DoFHandler<dim> & dof_handler_coarse,
+ const DoFHandler<dim> &dof_handler_fine,
+ const DoFHandler<dim> &dof_handler_coarse,
const AffineConstraints<Number> &constraint_fine =
AffineConstraints<Number>(),
const AffineConstraints<Number> &constraint_coarse =
* check if the given polynomial coarsening strategy is supported.
*/
void
- reinit(const DoFHandler<dim> & dof_handler_fine,
- const DoFHandler<dim> & dof_handler_coarse,
+ reinit(const DoFHandler<dim> &dof_handler_fine,
+ const DoFHandler<dim> &dof_handler_coarse,
const AffineConstraints<Number> &constraint_fine =
AffineConstraints<Number>(),
const AffineConstraints<Number> &constraint_coarse =
*/
void
interpolate(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const override;
/**
protected:
void
prolongate_and_add_internal(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const override;
void
restrict_and_add_internal(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const override;
private:
* @p dof_handler_fine and @p dof_handler_coarse).
*/
void
- reinit(const DoFHandler<dim> & dof_handler_fine,
- const DoFHandler<dim> & dof_handler_coarse,
- const Mapping<dim> & mapping_fine,
- const Mapping<dim> & mapping_coarse,
+ reinit(const DoFHandler<dim> &dof_handler_fine,
+ const DoFHandler<dim> &dof_handler_coarse,
+ const Mapping<dim> &mapping_fine,
+ const Mapping<dim> &mapping_coarse,
const AffineConstraints<Number> &constraint_fine =
AffineConstraints<Number>(),
const AffineConstraints<Number> &constraint_coarse =
*/
void
interpolate(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const override;
/**
*/
void
prolongate_and_add_internal(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const override;
/**
*/
void
restrict_and_add_internal(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const override;
private:
template <int n_components>
void
prolongate_and_add_internal_comp(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const;
/**
template <int n_components>
void
restrict_and_add_internal_comp(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const;
/**
*/
void
prolongate(const unsigned int to_level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
/**
* Perform prolongation.
*/
void
prolongate_and_add(const unsigned int to_level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
/**
* Perform restriction.
*/
virtual void
restrict_and_add(const unsigned int from_level,
- VectorType & dst,
- const VectorType & src) const override;
+ VectorType &dst,
+ const VectorType &src) const override;
/**
* Initialize internal vectors and copy @p src vector to the finest
*/
template <class InVector>
void
- copy_to_mg(const DoFHandler<dim> & dof_handler,
+ copy_to_mg(const DoFHandler<dim> &dof_handler,
MGLevelObject<VectorType> &dst,
- const InVector & src) const;
+ const InVector &src) const;
/**
* Initialize internal vectors and copy the values on the finest
*/
template <class OutVector>
void
- copy_from_mg(const DoFHandler<dim> & dof_handler,
- OutVector & dst,
+ copy_from_mg(const DoFHandler<dim> &dof_handler,
+ OutVector &dst,
const MGLevelObject<VectorType> &src) const;
/**
*/
template <class InVector>
void
- interpolate_to_mg(const DoFHandler<dim> & dof_handler,
+ interpolate_to_mg(const DoFHandler<dim> &dof_handler,
MGLevelObject<VectorType> &dst,
- const InVector & src) const;
+ const InVector &src) const;
/** @} */
*/
void
intitialize_internal_transfer(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
const SmartPointer<const MGConstrainedDoFs> &mg_constrained_dofs);
/**
template <class InVector>
void
initialize_dof_vector(const unsigned int level,
- VectorType & vector,
- const InVector & vector_reference,
+ VectorType &vector,
+ const InVector &vector_reference,
const bool omit_zeroing_entries) const;
/**
void
MGTransferMF<dim, Number>::initialize_dof_vector(
const unsigned int level,
- VectorType & vec,
- const InVector & vec_reference,
+ VectorType &vec,
+ const InVector &vec_reference,
const bool omit_zeroing_entries) const
{
std::shared_ptr<const Utilities::MPI::Partitioner> partitioner;
template <int dim, typename Number>
template <class InVector>
void
-MGTransferMF<dim, Number>::copy_to_mg(const DoFHandler<dim> & dof_handler,
+MGTransferMF<dim, Number>::copy_to_mg(const DoFHandler<dim> &dof_handler,
MGLevelObject<VectorType> &dst,
- const InVector & src) const
+ const InVector &src) const
{
(void)dof_handler;
template <class OutVector>
void
MGTransferMF<dim, Number>::copy_from_mg(
- const DoFHandler<dim> & dof_handler,
- OutVector & dst,
+ const DoFHandler<dim> &dof_handler,
+ OutVector &dst,
const MGLevelObject<VectorType> &src) const
{
(void)dof_handler;
public:
CellProlongator(const AlignedVector<Number> &prolongation_matrix,
const AlignedVector<Number> &prolongation_matrix_1d,
- const Number * evaluation_data_coarse,
- Number * evaluation_data_fine)
+ const Number *evaluation_data_coarse,
+ Number *evaluation_data_fine)
: prolongation_matrix(prolongation_matrix)
, prolongation_matrix_1d(prolongation_matrix_1d)
, evaluation_data_coarse(evaluation_data_coarse)
private:
const AlignedVector<Number> &prolongation_matrix;
const AlignedVector<Number> &prolongation_matrix_1d;
- const Number * evaluation_data_coarse;
- Number * evaluation_data_fine;
+ const Number *evaluation_data_coarse;
+ Number *evaluation_data_fine;
};
/**
public:
CellRestrictor(const AlignedVector<Number> &prolongation_matrix,
const AlignedVector<Number> &prolongation_matrix_1d,
- Number * evaluation_data_fine,
- Number * evaluation_data_coarse)
+ Number *evaluation_data_fine,
+ Number *evaluation_data_coarse)
: prolongation_matrix(prolongation_matrix)
, prolongation_matrix_1d(prolongation_matrix_1d)
, evaluation_data_fine(evaluation_data_fine)
private:
const AlignedVector<Number> &prolongation_matrix;
const AlignedVector<Number> &prolongation_matrix_1d;
- Number * evaluation_data_fine;
- Number * evaluation_data_coarse;
+ Number *evaluation_data_fine;
+ Number *evaluation_data_coarse;
};
class CellProlongatorTest
{
template <typename MeshType, typename OPType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
- void loop_over_active_or_level_cells(const MeshType & tria,
+ void loop_over_active_or_level_cells(const MeshType &tria,
const unsigned int level,
- const OPType & op)
+ const OPType &op)
{
if (level == numbers::invalid_unsigned_int)
{
FineDoFHandlerViewCell(
const std::function<bool()> &has_children_function,
const std::function<void(std::vector<types::global_dof_index> &)>
- & get_dof_indices_function,
+ &get_dof_indices_function,
const std::function<unsigned int()> &active_fe_index_function)
: has_children_function(has_children_function)
, get_dof_indices_function(get_dof_indices_function)
compute_weights(
const dealii::AffineConstraints<Number> &constraints_fine,
const MGTwoLevelTransfer<dim, LinearAlgebra::distributed::Vector<Number>>
- & transfer,
+ &transfer,
LinearAlgebra::distributed::Vector<Number> &touch_count)
{
touch_count.reinit(transfer.partitioner_fine);
template <int dim, typename Number>
static std::shared_ptr<const Utilities::MPI::Partitioner>
create_coarse_partitioner(
- const DoFHandler<dim> & dof_handler_coarse,
+ const DoFHandler<dim> &dof_handler_coarse,
const dealii::AffineConstraints<Number> &constraints_coarse,
const unsigned int mg_level_coarse)
{
template <int dim, typename Number>
static void
reinit_geometric_transfer(
- const DoFHandler<dim> & dof_handler_fine,
- const DoFHandler<dim> & dof_handler_coarse,
+ const DoFHandler<dim> &dof_handler_fine,
+ const DoFHandler<dim> &dof_handler_coarse,
const dealii::AffineConstraints<Number> &constraints_fine,
const dealii::AffineConstraints<Number> &constraints_coarse,
const unsigned int mg_level_fine,
}
else
{
- const auto & fe = fe_fine.base_element(0);
+ const auto &fe = fe_fine.base_element(0);
const unsigned int n_dofs_per_cell = fe.n_dofs_per_cell();
{
template <int dim, typename Number>
static void
reinit_polynomial_transfer(
- const DoFHandler<dim> & dof_handler_fine,
- const DoFHandler<dim> & dof_handler_coarse,
+ const DoFHandler<dim> &dof_handler_fine,
+ const DoFHandler<dim> &dof_handler_coarse,
const dealii::AffineConstraints<Number> &constraints_fine,
const dealii::AffineConstraints<Number> &constraints_coarse,
const unsigned int mg_level_fine,
{
SimpleVectorDataExchange(
const std::shared_ptr<const Utilities::MPI::Partitioner>
- & embedded_partitioner,
+ &embedded_partitioner,
AlignedVector<Number> &buffer)
: embedded_partitioner(embedded_partitioner)
, buffer(buffer)
private:
const std::shared_ptr<const Utilities::MPI::Partitioner>
embedded_partitioner;
- dealii::AlignedVector<Number> & buffer;
+ dealii::AlignedVector<Number> &buffer;
mutable std::vector<MPI_Request> requests;
};
template <int dim, int spacedim>
std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
create_geometric_coarsening_sequence(
- Triangulation<dim, spacedim> & fine_triangulation_in,
+ Triangulation<dim, spacedim> &fine_triangulation_in,
const RepartitioningPolicyTools::Base<dim, spacedim> &policy,
const bool keep_fine_triangulation,
const bool repartition_fine_triangulation)
template <int dim, int spacedim>
std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
create_geometric_coarsening_sequence(
- const Triangulation<dim, spacedim> & fine_triangulation_in,
+ const Triangulation<dim, spacedim> &fine_triangulation_in,
const RepartitioningPolicyTools::Base<dim, spacedim> &policy,
const bool repartition_fine_triangulation)
{
void
MGTwoLevelTransferBase<LinearAlgebra::distributed::Vector<Number>>::
prolongate_and_add(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const bool use_dst_inplace = this->vec_fine.size() == 0;
void
MGTwoLevelTransfer<dim, LinearAlgebra::distributed::Vector<Number>>::
prolongate_and_add_internal(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const unsigned int n_lanes = VectorizedArrayType::size();
AlignedVector<VectorizedArrayType> evaluation_data_fine;
AlignedVector<VectorizedArrayType> evaluation_data_coarse;
- const Number * weights = nullptr;
+ const Number *weights = nullptr;
const VectorizedArrayType *weights_compressed = nullptr;
if (this->fine_element_is_continuous)
template <typename Number>
void
MGTwoLevelTransferBase<LinearAlgebra::distributed::Vector<Number>>::
- restrict_and_add(LinearAlgebra::distributed::Vector<Number> & dst,
+ restrict_and_add(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const bool use_src_inplace = this->vec_fine.size() == 0;
void
MGTwoLevelTransfer<dim, LinearAlgebra::distributed::Vector<Number>>::
restrict_and_add_internal(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const unsigned int n_lanes = VectorizedArrayType::size();
AlignedVector<VectorizedArrayType> evaluation_data_fine;
AlignedVector<VectorizedArrayType> evaluation_data_coarse;
- const Number * weights = nullptr;
+ const Number *weights = nullptr;
const VectorizedArrayType *weights_compressed = nullptr;
if (this->fine_element_is_continuous)
template <int dim, typename Number>
void
MGTwoLevelTransfer<dim, LinearAlgebra::distributed::Vector<Number>>::
- interpolate(LinearAlgebra::distributed::Vector<Number> & dst,
+ interpolate(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const unsigned int n_lanes = VectorizedArrayType::size();
internal::MatrixFreeFunctions::ConstraintInfo<
dim,
VectorizedArray<Number, width>> &constraint_info_coarse,
- std::vector<unsigned int> & dof_indices_fine)
+ std::vector<unsigned int> &dof_indices_fine)
{
if (this->partitioner_coarse->is_globally_compatible(
*external_partitioner_coarse))
template <int dim, typename Number>
void
MGTwoLevelTransfer<dim, LinearAlgebra::distributed::Vector<Number>>::
- reinit_geometric_transfer(const DoFHandler<dim> & dof_handler_fine,
- const DoFHandler<dim> & dof_handler_coarse,
+ reinit_geometric_transfer(const DoFHandler<dim> &dof_handler_fine,
+ const DoFHandler<dim> &dof_handler_coarse,
const AffineConstraints<Number> &constraints_fine,
const AffineConstraints<Number> &constraints_coarse,
const unsigned int mg_level_fine,
void
MGTwoLevelTransfer<dim, LinearAlgebra::distributed::Vector<Number>>::
reinit_polynomial_transfer(
- const DoFHandler<dim> & dof_handler_fine,
- const DoFHandler<dim> & dof_handler_coarse,
+ const DoFHandler<dim> &dof_handler_fine,
+ const DoFHandler<dim> &dof_handler_coarse,
const AffineConstraints<Number> &constraints_fine,
const AffineConstraints<Number> &constraints_coarse,
const unsigned int mg_level_fine,
template <int dim, typename Number>
void
MGTwoLevelTransfer<dim, LinearAlgebra::distributed::Vector<Number>>::reinit(
- const DoFHandler<dim> & dof_handler_fine,
- const DoFHandler<dim> & dof_handler_coarse,
+ const DoFHandler<dim> &dof_handler_fine,
+ const DoFHandler<dim> &dof_handler_coarse,
const AffineConstraints<Number> &constraints_fine,
const AffineConstraints<Number> &constraints_coarse,
const unsigned int mg_level_fine,
template <int dim, typename Number>
void
MGTransferMF<dim, Number>::intitialize_internal_transfer(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
const SmartPointer<const MGConstrainedDoFs> &mg_constrained_dofs)
{
const unsigned int min_level = 0;
template <int dim, typename Number>
void
MGTransferMF<dim, Number>::prolongate(const unsigned int to_level,
- VectorType & dst,
- const VectorType & src) const
+ VectorType &dst,
+ const VectorType &src) const
{
dst = 0;
prolongate_and_add(to_level, dst, src);
template <int dim, typename Number>
void
MGTransferMF<dim, Number>::prolongate_and_add(const unsigned int to_level,
- VectorType & dst,
- const VectorType & src) const
+ VectorType &dst,
+ const VectorType &src) const
{
this->transfer[to_level]->prolongate_and_add(dst, src);
}
template <int dim, typename Number>
void
MGTransferMF<dim, Number>::restrict_and_add(const unsigned int from_level,
- VectorType & dst,
- const VectorType & src) const
+ VectorType &dst,
+ const VectorType &src) const
{
this->transfer[from_level]->restrict_and_add(dst, src);
}
std::vector<unsigned int>,
std::vector<types::global_dof_index>>
support_point_indices_to_dof_indices(
- const DoFHandler<dim, spacedim> & dof_handler,
- const DoFHandler<dim, spacedim> & dof_handler_support_points,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler_support_points,
const dealii::AffineConstraints<Number> &constraint)
{
// in case a FE_DGQ space of order 0 is provided, DoFs indices are always
std::vector<unsigned int>,
std::vector<types::global_dof_index>>
collect_unconstrained_unique_support_points(
- const DoFHandler<dim> & dof_handler,
- const Mapping<dim> & mapping,
+ const DoFHandler<dim> &dof_handler,
+ const Mapping<dim> &mapping,
const dealii::AffineConstraints<Number> &constraint)
{
AssertThrow(dof_handler.get_fe().has_support_points(),
for (unsigned int i = 0; i < local_support_point_indices.size(); ++i)
indices_state[local_support_point_indices[i]] = i;
- const auto & fe_support_point = dof_handler_support_points->get_fe();
+ const auto &fe_support_point = dof_handler_support_points->get_fe();
FEValues<dim> fe_values(mapping,
fe_support_point,
Quadrature<dim>(
template <int dim, typename Number>
void
MGTwoLevelTransferNonNested<dim, LinearAlgebra::distributed::Vector<Number>>::
- reinit(const DoFHandler<dim> & dof_handler_fine,
- const DoFHandler<dim> & dof_handler_coarse,
- const Mapping<dim> & mapping_fine,
- const Mapping<dim> & mapping_coarse,
+ reinit(const DoFHandler<dim> &dof_handler_fine,
+ const DoFHandler<dim> &dof_handler_coarse,
+ const Mapping<dim> &mapping_fine,
+ const Mapping<dim> &mapping_coarse,
const AffineConstraints<Number> &constraint_fine,
const AffineConstraints<Number> &constraint_coarse)
{
constraint_info.finalize();
- const auto & fe_base = dof_handler_coarse.get_fe().base_element(0);
+ const auto &fe_base = dof_handler_coarse.get_fe().base_element(0);
const unsigned int n_components = dof_handler_coarse.get_fe().n_components();
if (const auto fe = dynamic_cast<const FE_Q<dim> *>(&fe_base))
void
MGTwoLevelTransferNonNested<dim, LinearAlgebra::distributed::Vector<Number>>::
prolongate_and_add_internal_comp(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
using Traits =
void
MGTwoLevelTransferNonNested<dim, LinearAlgebra::distributed::Vector<Number>>::
prolongate_and_add_internal(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
if (this->fe_coarse->n_components() == 1)
void
MGTwoLevelTransferNonNested<dim, LinearAlgebra::distributed::Vector<Number>>::
restrict_and_add_internal_comp(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
using Traits =
void
MGTwoLevelTransferNonNested<dim, LinearAlgebra::distributed::Vector<Number>>::
restrict_and_add_internal(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
if (this->fe_coarse->n_components() == 1)
template <int dim, typename Number>
void
MGTwoLevelTransferNonNested<dim, LinearAlgebra::distributed::Vector<Number>>::
- interpolate(LinearAlgebra::distributed::Vector<Number> & dst,
+ interpolate(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
AssertThrow(false, ExcNotImplemented());
void
fill_copy_indices(
const DoFHandler<dim, spacedim> &dof_handler,
- const MGConstrainedDoFs * mg_constrained_dofs,
+ const MGConstrainedDoFs *mg_constrained_dofs,
std::vector<std::vector<
std::pair<types::global_dof_index, types::global_dof_index>>>
©_indices,
©_indices_global_mine,
std::vector<std::vector<
std::pair<types::global_dof_index, types::global_dof_index>>>
- & copy_indices_level_mine,
+ ©_indices_level_mine,
const bool skip_interface_dofs = true);
template <int dim, typename Number>
void
setup_transfer(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
const MGConstrainedDoFs *mg_constrained_dofs,
const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
- & external_partitioners,
- ElementInfo<Number> & elem_info,
+ &external_partitioners,
+ ElementInfo<Number> &elem_info,
std::vector<std::vector<unsigned int>> &level_dof_indices,
std::vector<std::vector<std::pair<unsigned int, unsigned int>>>
- & parent_child_connect,
+ &parent_child_connect,
std::vector<unsigned int> &n_owned_level_cells,
std::vector<std::vector<std::vector<unsigned short>>> &dirichlet_indices,
- std::vector<std::vector<Number>> & weights_on_refined,
+ std::vector<std::vector<Number>> &weights_on_refined,
std::vector<Table<2, unsigned int>> ©_indices_global_mine,
MGLevelObject<std::shared_ptr<const Utilities::MPI::Partitioner>>
&vector_partitioners);
*/
void
resolve_identity_constraints(
- const MGConstrainedDoFs * mg_constrained_dofs,
+ const MGConstrainedDoFs *mg_constrained_dofs,
const unsigned int level,
std::vector<types::global_dof_index> &dof_indices);
virtual void
prolongate(
const unsigned int to_level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const override;
virtual void
prolongate_and_add(
const unsigned int to_level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const override;
/**
virtual void
restrict_and_add(
const unsigned int from_level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const override;
/**
template <typename BlockVectorType2>
void
interpolate_to_mg(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &dst,
- const BlockVectorType2 & src) const;
+ const BlockVectorType2 &src) const;
/**
* Memory used by this object.
void
do_prolongate_add(
const unsigned int to_level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const;
/**
template <int degree>
void
do_restrict_add(const unsigned int from_level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const;
};
virtual void
prolongate(
const unsigned int to_level,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const override;
virtual void
prolongate_and_add(
const unsigned int to_level,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const override;
/**
virtual void
restrict_and_add(
const unsigned int from_level,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const override;
/**
template <typename BlockVectorType2>
void
copy_to_mg(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
- const BlockVectorType2 & src) const;
+ const BlockVectorType2 &src) const;
/**
* Same as above for the case that each block has its own DoFHandler.
template <typename BlockVectorType2>
void
copy_to_mg(
- const std::vector<const DoFHandler<dim> *> & dof_handler,
+ const std::vector<const DoFHandler<dim> *> &dof_handler,
MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
- const BlockVectorType2 & src) const;
+ const BlockVectorType2 &src) const;
/**
* Transfer from multi-level block-vector to normal vector.
void
copy_from_mg(
const DoFHandler<dim> &dof_handler,
- BlockVectorType2 & dst,
+ BlockVectorType2 &dst,
const MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &src)
const;
void
copy_from_mg(
const std::vector<const DoFHandler<dim> *> &dof_handler,
- BlockVectorType2 & dst,
+ BlockVectorType2 &dst,
const MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &src)
const;
template <typename BlockVectorType2>
void
MGTransferMatrixFree<dim, Number>::interpolate_to_mg(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &dst,
- const BlockVectorType2 & src) const
+ const BlockVectorType2 &src) const
{
const unsigned int min_level = dst.min_level();
const unsigned int max_level = dst.max_level();
template <typename BlockVectorType2>
void
MGTransferBlockMatrixFreeBase<dim, Number, TransferType>::copy_to_mg(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
- const BlockVectorType2 & src) const
+ const BlockVectorType2 &src) const
{
Assert(same_for_all,
ExcMessage(
template <typename BlockVectorType2>
void
MGTransferBlockMatrixFreeBase<dim, Number, TransferType>::copy_to_mg(
- const std::vector<const DoFHandler<dim> *> & dof_handler,
+ const std::vector<const DoFHandler<dim> *> &dof_handler,
MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
- const BlockVectorType2 & src) const
+ const BlockVectorType2 &src) const
{
const unsigned int n_blocks = src.n_blocks();
AssertDimension(dof_handler.size(), n_blocks);
void
MGTransferBlockMatrixFreeBase<dim, Number, TransferType>::copy_from_mg(
const DoFHandler<dim> &dof_handler,
- BlockVectorType2 & dst,
+ BlockVectorType2 &dst,
const MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &src)
const
{
void
MGTransferBlockMatrixFreeBase<dim, Number, TransferType>::copy_from_mg(
const std::vector<const DoFHandler<dim> *> &dof_handler,
- BlockVectorType2 & dst,
+ BlockVectorType2 &dst,
const MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &src)
const
{
void
MGTransferBlockMatrixFreeBase<dim, Number, TransferType>::prolongate(
const unsigned int to_level,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
const unsigned int n_blocks = src.n_blocks();
void
MGTransferBlockMatrixFreeBase<dim, Number, TransferType>::prolongate_and_add(
const unsigned int to_level,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
const unsigned int n_blocks = src.n_blocks();
void
MGTransferBlockMatrixFreeBase<dim, Number, TransferType>::restrict_and_add(
const unsigned int from_level,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
const unsigned int n_blocks = src.n_blocks();
* the course of the computations. You should therefore create objects of
* this type as late as possible.
*/
- Multigrid(const MGMatrixBase<VectorType> & matrix,
+ Multigrid(const MGMatrixBase<VectorType> &matrix,
const MGCoarseGridBase<VectorType> &coarse,
- const MGTransferBase<VectorType> & transfer,
- const MGSmootherBase<VectorType> & pre_smooth,
- const MGSmootherBase<VectorType> & post_smooth,
+ const MGTransferBase<VectorType> &transfer,
+ const MGSmootherBase<VectorType> &pre_smooth,
+ const MGSmootherBase<VectorType> &post_smooth,
const unsigned int minlevel = 0,
const unsigned int maxlevel = numbers::invalid_unsigned_int,
Cycle cycle = v_cycle);
*/
PreconditionMG(const DoFHandler<dim> &dof_handler,
Multigrid<VectorType> &mg,
- const TransferType & transfer);
+ const TransferType &transfer);
/**
* Same as above in case every component of a block vector
* uses its own DoFHandler.
*/
PreconditionMG(const std::vector<const DoFHandler<dim> *> &dof_handler,
- Multigrid<VectorType> & mg,
- const TransferType & transfer);
+ Multigrid<VectorType> &mg,
+ const TransferType &transfer);
/**
* Dummy function needed by other classes.
template <typename VectorType>
-Multigrid<VectorType>::Multigrid(const MGMatrixBase<VectorType> & matrix,
+Multigrid<VectorType>::Multigrid(const MGMatrixBase<VectorType> &matrix,
const MGCoarseGridBase<VectorType> &coarse,
- const MGTransferBase<VectorType> & transfer,
- const MGSmootherBase<VectorType> & pre_smooth,
+ const MGTransferBase<VectorType> &transfer,
+ const MGSmootherBase<VectorType> &pre_smooth,
const MGSmootherBase<VectorType> &post_smooth,
const unsigned int min_level,
const unsigned int max_level,
typename OtherVectorType>
std::enable_if_t<TransferType::supports_dof_handler_vector>
vmult(const std::vector<const DoFHandler<dim> *> &dof_handler_vector,
- Multigrid<VectorType> & multigrid,
- const TransferType & transfer,
- OtherVectorType & dst,
- const OtherVectorType & src,
+ Multigrid<VectorType> &multigrid,
+ const TransferType &transfer,
+ OtherVectorType &dst,
+ const OtherVectorType &src,
const bool uses_dof_handler_vector,
- const typename dealii::mg::Signals & signals,
+ const typename dealii::mg::Signals &signals,
int)
{
signals.transfer_to_mg(true);
typename OtherVectorType>
void
vmult(const std::vector<const DoFHandler<dim> *> &dof_handler_vector,
- Multigrid<VectorType> & multigrid,
- const TransferType & transfer,
- OtherVectorType & dst,
- const OtherVectorType & src,
+ Multigrid<VectorType> &multigrid,
+ const TransferType &transfer,
+ OtherVectorType &dst,
+ const OtherVectorType &src,
const bool uses_dof_handler_vector,
- const typename dealii::mg::Signals & signals,
+ const typename dealii::mg::Signals &signals,
...)
{
(void)uses_dof_handler_vector;
typename OtherVectorType>
std::enable_if_t<TransferType::supports_dof_handler_vector>
vmult_add(const std::vector<const DoFHandler<dim> *> &dof_handler_vector,
- Multigrid<VectorType> & multigrid,
- const TransferType & transfer,
- OtherVectorType & dst,
- const OtherVectorType & src,
+ Multigrid<VectorType> &multigrid,
+ const TransferType &transfer,
+ OtherVectorType &dst,
+ const OtherVectorType &src,
const bool uses_dof_handler_vector,
const typename dealii::mg::Signals &signals,
int)
typename OtherVectorType>
void
vmult_add(const std::vector<const DoFHandler<dim> *> &dof_handler_vector,
- Multigrid<VectorType> & multigrid,
- const TransferType & transfer,
- OtherVectorType & dst,
- const OtherVectorType & src,
+ Multigrid<VectorType> &multigrid,
+ const TransferType &transfer,
+ OtherVectorType &dst,
+ const OtherVectorType &src,
const bool uses_dof_handler_vector,
const typename dealii::mg::Signals &signals,
...)
PreconditionMG<dim, VectorType, TransferType>::PreconditionMG(
const DoFHandler<dim> &dof_handler,
Multigrid<VectorType> &mg,
- const TransferType & transfer)
+ const TransferType &transfer)
: dof_handler_vector(1, &dof_handler)
, dof_handler_vector_raw(1, &dof_handler)
, multigrid(&mg)
template <int dim, typename VectorType, typename TransferType>
PreconditionMG<dim, VectorType, TransferType>::PreconditionMG(
const std::vector<const DoFHandler<dim> *> &dof_handler,
- Multigrid<VectorType> & mg,
- const TransferType & transfer)
+ Multigrid<VectorType> &mg,
+ const TransferType &transfer)
: dof_handler_vector(dof_handler.size())
, dof_handler_vector_raw(dof_handler.size())
, multigrid(&mg)
template <typename OtherVectorType>
void
PreconditionMG<dim, VectorType, TransferType>::vmult(
- OtherVectorType & dst,
+ OtherVectorType &dst,
const OtherVectorType &src) const
{
internal::PreconditionMGImplementation::vmult(dof_handler_vector_raw,
template <typename OtherVectorType>
void
PreconditionMG<dim, VectorType, TransferType>::vmult_add(
- OtherVectorType & dst,
+ OtherVectorType &dst,
const OtherVectorType &src) const
{
internal::PreconditionMGImplementation::vmult_add(dof_handler_vector_raw,
create_coupling_sparsity_pattern(
const DoFHandler<dim0, spacedim> &space_dh,
const DoFHandler<dim1, spacedim> &immersed_dh,
- const Quadrature<dim1> & quad,
- SparsityPatternBase & sparsity,
- const AffineConstraints<number> & constraints = {},
- const ComponentMask & space_comps = {},
- const ComponentMask & immersed_comps = {},
- const Mapping<dim0, spacedim> & space_mapping =
+ const Quadrature<dim1> &quad,
+ SparsityPatternBase &sparsity,
+ const AffineConstraints<number> &constraints = {},
+ const ComponentMask &space_comps = {},
+ const ComponentMask &immersed_comps = {},
+ const Mapping<dim0, spacedim> &space_mapping =
StaticMappingQ1<dim0, spacedim>::mapping,
const Mapping<dim1, spacedim> &immersed_mapping =
StaticMappingQ1<dim1, spacedim>::mapping,
void
create_coupling_sparsity_pattern(
const GridTools::Cache<dim0, spacedim> &cache,
- const DoFHandler<dim0, spacedim> & space_dh,
- const DoFHandler<dim1, spacedim> & immersed_dh,
- const Quadrature<dim1> & quad,
- SparsityPatternBase & sparsity,
- const AffineConstraints<number> & constraints = {},
- const ComponentMask & space_comps = {},
- const ComponentMask & immersed_comps = {},
- const Mapping<dim1, spacedim> & immersed_mapping =
+ const DoFHandler<dim0, spacedim> &space_dh,
+ const DoFHandler<dim1, spacedim> &immersed_dh,
+ const Quadrature<dim1> &quad,
+ SparsityPatternBase &sparsity,
+ const AffineConstraints<number> &constraints = {},
+ const ComponentMask &space_comps = {},
+ const ComponentMask &immersed_comps = {},
+ const Mapping<dim1, spacedim> &immersed_mapping =
StaticMappingQ1<dim1, spacedim>::mapping,
const AffineConstraints<number> &immersed_constraints =
AffineConstraints<number>());
template <int dim0, int dim1, int spacedim, typename Matrix>
void
create_coupling_mass_matrix(
- const DoFHandler<dim0, spacedim> & space_dh,
- const DoFHandler<dim1, spacedim> & immersed_dh,
- const Quadrature<dim1> & quad,
- Matrix & matrix,
+ const DoFHandler<dim0, spacedim> &space_dh,
+ const DoFHandler<dim1, spacedim> &immersed_dh,
+ const Quadrature<dim1> &quad,
+ Matrix &matrix,
const AffineConstraints<typename Matrix::value_type> &constraints =
AffineConstraints<typename Matrix::value_type>(),
- const ComponentMask & space_comps = {},
- const ComponentMask & immersed_comps = {},
+ const ComponentMask &space_comps = {},
+ const ComponentMask &immersed_comps = {},
const Mapping<dim0, spacedim> &space_mapping =
StaticMappingQ1<dim0, spacedim>::mapping,
const Mapping<dim1, spacedim> &immersed_mapping =
template <int dim0, int dim1, int spacedim, typename Matrix>
void
create_coupling_mass_matrix(
- const GridTools::Cache<dim0, spacedim> & cache,
- const DoFHandler<dim0, spacedim> & space_dh,
- const DoFHandler<dim1, spacedim> & immersed_dh,
- const Quadrature<dim1> & quad,
- Matrix & matrix,
+ const GridTools::Cache<dim0, spacedim> &cache,
+ const DoFHandler<dim0, spacedim> &space_dh,
+ const DoFHandler<dim1, spacedim> &immersed_dh,
+ const Quadrature<dim1> &quad,
+ Matrix &matrix,
const AffineConstraints<typename Matrix::value_type> &constraints =
AffineConstraints<typename Matrix::value_type>(),
- const ComponentMask & space_comps = {},
- const ComponentMask & immersed_comps = {},
+ const ComponentMask &space_comps = {},
+ const ComponentMask &immersed_comps = {},
const Mapping<dim1, spacedim> &immersed_mapping =
StaticMappingQ1<dim1, spacedim>::mapping,
const AffineConstraints<typename Matrix::value_type> &immersed_constraints =
template <int dim0, int dim1, int spacedim, typename Number = double>
void
create_coupling_sparsity_pattern(
- const double & epsilon,
+ const double &epsilon,
const GridTools::Cache<dim0, spacedim> &cache0,
const GridTools::Cache<dim1, spacedim> &cache1,
- const DoFHandler<dim0, spacedim> & dh0,
- const DoFHandler<dim1, spacedim> & dh1,
- const Quadrature<dim1> & quad,
- SparsityPatternBase & sparsity,
+ const DoFHandler<dim0, spacedim> &dh0,
+ const DoFHandler<dim1, spacedim> &dh1,
+ const Quadrature<dim1> &quad,
+ SparsityPatternBase &sparsity,
const AffineConstraints<Number> &constraints0 = AffineConstraints<Number>(),
- const ComponentMask & comps0 = {},
- const ComponentMask & comps1 = {});
+ const ComponentMask &comps0 = {},
+ const ComponentMask &comps1 = {});
/**
* Create a coupling @ref GlossMassMatrix "mass matrix" for non-matching independent grids,
template <int dim0, int dim1, int spacedim, typename Matrix>
void
create_coupling_mass_matrix(
- Functions::CutOffFunctionBase<spacedim> & kernel,
- const double & epsilon,
- const GridTools::Cache<dim0, spacedim> & cache0,
- const GridTools::Cache<dim1, spacedim> & cache1,
- const DoFHandler<dim0, spacedim> & dh0,
- const DoFHandler<dim1, spacedim> & dh1,
- const Quadrature<dim0> & quadrature0,
- const Quadrature<dim1> & quadrature1,
- Matrix & matrix,
+ Functions::CutOffFunctionBase<spacedim> &kernel,
+ const double &epsilon,
+ const GridTools::Cache<dim0, spacedim> &cache0,
+ const GridTools::Cache<dim1, spacedim> &cache1,
+ const DoFHandler<dim0, spacedim> &dh0,
+ const DoFHandler<dim1, spacedim> &dh1,
+ const Quadrature<dim0> &quadrature0,
+ const Quadrature<dim1> &quadrature1,
+ Matrix &matrix,
const AffineConstraints<typename Matrix::value_type> &constraints0 =
AffineConstraints<typename Matrix::value_type>(),
const ComponentMask &comps0 = {},
* @note Currently this class is only implemented for MappingCartesian,
* MappingQ and MappingFEField.
*/
- FEImmersedSurfaceValues(const Mapping<dim> & mapping,
- const FiniteElement<dim> & element,
+ FEImmersedSurfaceValues(const Mapping<dim> &mapping,
+ const FiniteElement<dim> &element,
const ImmersedSurfaceQuadrature<dim> &quadrature,
const UpdateFlags update_flags);
*/
template <typename VectorType>
FEValues(const hp::FECollection<dim> &fe_collection,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const RegionUpdateFlags region_update_flags,
- const MeshClassifier<dim> & mesh_classifier,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
- const AdditionalData & additional_data = AdditionalData());
+ const MeshClassifier<dim> &mesh_classifier,
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
+ const AdditionalData &additional_data = AdditionalData());
/**
* Constructor.
*/
template <typename VectorType>
FEValues(const hp::MappingCollection<dim> &mapping_collection,
- const hp::FECollection<dim> & fe_collection,
- const hp::QCollection<dim> & q_collection,
- const hp::QCollection<1> & q_collection_1d,
+ const hp::FECollection<dim> &fe_collection,
+ const hp::QCollection<dim> &q_collection,
+ const hp::QCollection<1> &q_collection_1d,
const RegionUpdateFlags region_update_flags,
- const MeshClassifier<dim> & mesh_classifier,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
+ const MeshClassifier<dim> &mesh_classifier,
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
const AdditionalData &additional_data = AdditionalData());
/**
*/
template <typename VectorType>
FEInterfaceValues(const hp::FECollection<dim> &fe_collection,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const RegionUpdateFlags region_update_flags,
- const MeshClassifier<dim> & mesh_classifier,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
+ const MeshClassifier<dim> &mesh_classifier,
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
const AdditionalData &additional_data = AdditionalData());
/**
*/
template <typename VectorType>
FEInterfaceValues(const hp::MappingCollection<dim> &mapping_collection,
- const hp::FECollection<dim> & fe_collection,
- const hp::QCollection<dim - 1> & q_collection,
- const hp::QCollection<1> & q_collection_1d,
+ const hp::FECollection<dim> &fe_collection,
+ const hp::QCollection<dim - 1> &q_collection,
+ const hp::QCollection<1> &q_collection_1d,
const RegionUpdateFlags region_update_flags,
- const MeshClassifier<dim> & mesh_classifier,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
+ const MeshClassifier<dim> &mesh_classifier,
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
const AdditionalData &additional_data = AdditionalData());
/**
*/
template <typename CellIteratorType, typename CellNeighborIteratorType>
void
- reinit(const CellIteratorType & cell,
+ reinit(const CellIteratorType &cell,
const unsigned int face_no,
const unsigned int sub_face_no,
const CellNeighborIteratorType &cell_neighbor,
template <int dim>
template <typename CellIteratorType, typename CellNeighborIteratorType>
inline void
- FEInterfaceValues<dim>::reinit(const CellIteratorType & cell,
+ FEInterfaceValues<dim>::reinit(const CellIteratorType &cell,
const unsigned int face_no,
const unsigned int sub_face_no,
const CellNeighborIteratorType &cell_neighbor,
* surface normals. The points, weights and normals should be with respect
* to reference space, and the normals should be normalized.
*/
- ImmersedSurfaceQuadrature(const std::vector<Point<dim>> & points,
- const std::vector<double> & weights,
+ ImmersedSurfaceQuadrature(const std::vector<Point<dim>> &points,
+ const std::vector<double> &weights,
const std::vector<Tensor<1, spacedim>> &normals);
/**
* quadrature formula.
*/
void
- push_back(const Point<dim> & point,
+ push_back(const Point<dim> &point,
const double weight,
const Tensor<1, spacedim> &normal);
static UpdateFlags
required_update_flags(
const SmartPointer<const Mapping<dim, spacedim>> mapping,
- const UpdateFlags & update_flags)
+ const UpdateFlags &update_flags)
{
return mapping->requires_update_flags(update_flags);
}
static void
compute_mapping_data_for_quadrature(
const SmartPointer<const Mapping<dim, spacedim>> mapping,
- const UpdateFlags & update_flags_mapping,
+ const UpdateFlags &update_flags_mapping,
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
CellSimilarity::Similarity &cell_similarity,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
std::shared_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
internal_mapping_data,
MappingData &mapping_data)
static void
compute_mapping_data_for_immersed_surface_quadrature(
const SmartPointer<const Mapping<dim, spacedim>> mapping,
- const UpdateFlags & update_flags_mapping,
+ const UpdateFlags &update_flags_mapping,
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const ImmersedSurfaceQuadrature<dim> & quadrature,
+ const ImmersedSurfaceQuadrature<dim> &quadrature,
std::shared_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
internal_mapping_data,
MappingData &mapping_data)
static void
compute_mapping_data_for_face_quadrature(
const SmartPointer<const Mapping<dim, spacedim>> mapping,
- const UpdateFlags & update_flags_mapping,
+ const UpdateFlags &update_flags_mapping,
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
std::shared_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
internal_mapping_data,
MappingData &mapping_data)
* @param additional_data Additional data for the class to specify the
* behavior during reinitialization.
*/
- MappingInfo(const Mapping<dim> & mapping,
+ MappingInfo(const Mapping<dim> &mapping,
const UpdateFlags update_flags,
const AdditionalData additional_data = AdditionalData());
template <typename ContainerType>
void
reinit_cells(
- const ContainerType & cell_iterator_range,
+ const ContainerType &cell_iterator_range,
const std::vector<std::vector<Point<dim>>> &unit_points_vector,
const unsigned int n_unfiltered_cells = numbers::invalid_unsigned_int);
template <typename ContainerType>
void
reinit_cells(
- const ContainerType & cell_iterator_range,
+ const ContainerType &cell_iterator_range,
const std::vector<Quadrature<dim>> &quadrature_vector,
const unsigned int n_unfiltered_cells = numbers::invalid_unsigned_int);
template <typename Iterator>
void
reinit_surface(
- const IteratorRange<Iterator> & cell_iterator_range,
+ const IteratorRange<Iterator> &cell_iterator_range,
const std::vector<ImmersedSurfaceQuadrature<dim>> &quadrature_vector,
const unsigned int n_unfiltered_cells = numbers::invalid_unsigned_int);
template <typename Iterator>
void
reinit_faces(
- const IteratorRange<Iterator> & cell_iterator_range,
+ const IteratorRange<Iterator> &cell_iterator_range,
const std::vector<std::vector<Quadrature<dim - 1>>> &quadrature_vector,
const unsigned int n_unfiltered_cells = numbers::invalid_unsigned_int);
store_mapping_data(const unsigned int unit_points_index_offset,
const unsigned int n_q_points,
const unsigned int n_q_points_unvectorized,
- const MappingData & mapping_data,
+ const MappingData &mapping_data,
const std::vector<double> &weights);
/**
template <int dim, int spacedim, typename Number>
MappingInfo<dim, spacedim, Number>::MappingInfo(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const UpdateFlags update_flags,
const AdditionalData additional_data)
: mapping(&mapping)
void
MappingInfo<dim, spacedim, Number>::reinit(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const std::vector<Point<dim>> & unit_points_in)
+ const std::vector<Point<dim>> &unit_points_in)
{
reinit(cell, Quadrature<dim>(unit_points_in));
}
void
MappingInfo<dim, spacedim, Number>::reinit(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const ArrayView<const Point<dim>> & unit_points_in)
+ const ArrayView<const Point<dim>> &unit_points_in)
{
reinit(cell,
std::vector<Point<dim>>(unit_points_in.begin(),
void
MappingInfo<dim, spacedim, Number>::reinit(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Quadrature<dim> & quadrature)
+ const Quadrature<dim> &quadrature)
{
n_q_points_unvectorized.resize(1);
n_q_points_unvectorized[0] = quadrature.size();
template <typename ContainerType>
void
MappingInfo<dim, spacedim, Number>::reinit_cells(
- const ContainerType & cell_iterator_range,
+ const ContainerType &cell_iterator_range,
const std::vector<std::vector<Point<dim>>> &unit_points_vector,
const unsigned int n_unfiltered_cells)
{
template <typename ContainerType>
void
MappingInfo<dim, spacedim, Number>::reinit_cells(
- const ContainerType & cell_iterator_range,
+ const ContainerType &cell_iterator_range,
const std::vector<Quadrature<dim>> &quadrature_vector,
const unsigned int n_unfiltered_cells)
{
template <typename Iterator>
void
MappingInfo<dim, spacedim, Number>::reinit_surface(
- const IteratorRange<Iterator> & cell_iterator_range,
+ const IteratorRange<Iterator> &cell_iterator_range,
const std::vector<ImmersedSurfaceQuadrature<dim>> &quadrature_vector,
const unsigned int n_unfiltered_cells)
{
template <typename Iterator>
void
MappingInfo<dim, spacedim, Number>::reinit_faces(
- const IteratorRange<Iterator> & cell_iterator_range,
+ const IteratorRange<Iterator> &cell_iterator_range,
const std::vector<std::vector<Quadrature<dim - 1>>> &quadrature_vector,
const unsigned int n_unfiltered_cells)
{
const unsigned int n_q_points,
const unsigned int n_q_points_unvectorized,
const MappingInfo::MappingData &mapping_data,
- const std::vector<double> & weights)
+ const std::vector<double> &weights)
{
const unsigned int n_lanes =
dealii::internal::VectorizedArrayTrait<Number>::width();
*/
template <typename VectorType>
MeshClassifier(const DoFHandler<dim> &level_set_dof_handler,
- const VectorType & level_set);
+ const VectorType &level_set);
/**
* Constructor. Takes the triangulation that should be classified, a
* @note The Function and the FiniteElement must both have a single component.
*/
MeshClassifier(const Triangulation<dim> &triangulation,
- const Function<dim> & level_set,
+ const Function<dim> &level_set,
const FiniteElement<dim> &element);
/**
*/
QuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
- const AdditionalData & additional_data = AdditionalData());
+ const AdditionalData &additional_data = AdditionalData());
/**
* Clears the inside, outside and surface quadratures.
* existing quadrature instead.
*/
void
- generate_append(const Function<dim> & level_set,
+ generate_append(const Function<dim> &level_set,
const BoundingBox<dim> &box);
/**
*/
FaceQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
- const AdditionalData & additional_data = AdditionalData());
+ const AdditionalData &additional_data = AdditionalData());
/**
* Clears the inside, outside and surface quadratures.
* incoming function.
*/
void
- generate(const Function<dim> & level_set,
+ generate(const Function<dim> &level_set,
const BoundingBox<dim> &box,
const unsigned int face_index);
* existing quadrature instead.
*/
void
- generate_append(const Function<dim> & level_set,
+ generate_append(const Function<dim> &level_set,
const BoundingBox<dim> &box,
const unsigned int face_index);
*/
FaceQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
- const AdditionalData & additional_data = AdditionalData());
+ const AdditionalData &additional_data = AdditionalData());
/**
* Does nothing. Exists for compatibility reasons.
* get_surface_quadrature().
*/
void
- generate(const Function<1> & level_set,
+ generate(const Function<1> &level_set,
const BoundingBox<1> &box,
const unsigned int face_index);
* existing quadrature instead.
*/
void
- generate_append(const Function<1> & level_set,
+ generate_append(const Function<1> &level_set,
const BoundingBox<1> &box,
const unsigned int face_index);
template <typename VectorType>
DiscreteQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
- const AdditionalData & additional_data = AdditionalData());
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
+ const AdditionalData &additional_data = AdditionalData());
/**
* Construct immersed quadratures rules based on the discrete level
template <typename VectorType>
DiscreteFaceQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
- const AdditionalData & additional_data = AdditionalData());
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
+ const AdditionalData &additional_data = AdditionalData());
/**
* Construct immersed quadratures rules based on the discrete level
*/
void
find_roots(const std::vector<std::reference_wrapper<const Function<1>>>
- & functions,
+ &functions,
const BoundingBox<1> &interval,
- std::vector<double> & roots);
+ std::vector<double> &roots);
private:
/**
* of times this function has been called recursively.
*/
void
- find_roots(const Function<1> & function,
+ find_roots(const Function<1> &function,
const BoundingBox<1> &interval,
const unsigned int recursion_depth,
- std::vector<double> & roots);
+ std::vector<double> &roots);
const AdditionalData additional_data;
};
* Constructor. Takes the same parameters as QuadratureGenerator.
*/
UpThroughDimensionCreator(
- const hp::QCollection<1> & q_collection1D,
+ const hp::QCollection<1> &q_collection1D,
const AdditionalQGeneratorData &additional_data);
/**
*/
void
generate(const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
- const BoundingBox<dim> & box,
+ &level_sets,
+ const BoundingBox<dim> &box,
const Quadrature<dim - 1> &low_dim_quadrature,
const unsigned int height_function_direction,
- QPartitioning<dim> & q_partitioning);
+ QPartitioning<dim> &q_partitioning);
/**
* Set which 1d-quadrature in the collection passed to the constructor
const Point<dim - 1> &point,
const double weight,
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
- const BoundingBox<dim> & box,
+ &level_sets,
+ const BoundingBox<dim> &box,
const unsigned int height_function_direction,
ImmersedSurfaceQuadrature<dim> &surface_quadrature);
class QGeneratorBase
{
public:
- QGeneratorBase(const hp::QCollection<1> & q_collection1D,
+ QGeneratorBase(const hp::QCollection<1> &q_collection1D,
const AdditionalQGeneratorData &additional_data);
/**
/**
* Constructor. Takes the same parameters QuadratureGenerator.
*/
- QGenerator(const hp::QCollection<1> & q_collection1D,
+ QGenerator(const hp::QCollection<1> &q_collection1D,
const AdditionalQGeneratorData &additional_data);
/**
*/
void
generate(const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
+ &level_sets,
const BoundingBox<dim> &box,
const unsigned int n_box_splits);
create_low_dim_quadratures(
const unsigned int height_function_direction,
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
+ &level_sets,
const BoundingBox<dim> &box,
const unsigned int n_box_splits);
create_high_dim_quadratures(
const unsigned int height_function_direction,
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
+ &level_sets,
const BoundingBox<dim> &box);
/**
void
split_box_and_recurse(
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
- const BoundingBox<dim> & box,
+ &level_sets,
+ const BoundingBox<dim> &box,
const std::optional<HeightDirectionData> &direction_data,
const unsigned int n_box_splits);
void
use_midpoint_method(
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
+ &level_sets,
const BoundingBox<dim> &box);
/**
/**
* Constructor. Takes the same parameters QuadratureGenerator.
*/
- QGenerator(const hp::QCollection<1> & quadratures1D,
+ QGenerator(const hp::QCollection<1> &quadratures1D,
const AdditionalQGeneratorData &additional_data);
/**
*/
void
generate(const std::vector<std::reference_wrapper<const Function<1>>>
- & level_sets,
+ &level_sets,
const BoundingBox<1> &box,
const unsigned int n_box_splits);
void
tensor_point_with_1D_quadrature(const Point<dim - 1> &point,
const double weight,
- const Quadrature<1> & quadrature1D,
+ const Quadrature<1> &quadrature1D,
const double start,
const double end,
const unsigned int component_in_dim,
Definiteness
pointwise_definiteness(
const std::vector<std::reference_wrapper<const Function<dim>>>
- & functions,
+ &functions,
const Point<dim> &point);
*/
virtual void
set_subcell(const std::vector<unsigned int> &mask,
- const BoundingBox<dim> & subcell_box) = 0;
+ const BoundingBox<dim> &subcell_box) = 0;
/**
* Returns flag indicating if the finite element is FE_Q_iso_Q1.
template <int dim, int spacedim, typename value_type>
std::vector<value_type>
preserve(const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const value_type parent_value);
/**
template <int dim, int spacedim, typename value_type>
std::vector<value_type>
split(const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const value_type parent_value);
/**
template <int dim, int spacedim, typename value_type>
std::vector<value_type>
l2_norm(const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const value_type parent_value);
} // namespace Refinement
value_type
check_equality(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const std::vector<value_type> &children_values);
/**
template <int dim, int spacedim, typename value_type>
value_type
sum(const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const std::vector<value_type> &children_values);
/**
template <int dim, int spacedim, typename value_type>
value_type
l2_norm(const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const std::vector<value_type> &children_values);
/**
template <int dim, int spacedim, typename value_type>
value_type
mean(const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const std::vector<value_type> &children_values);
/**
template <int dim, int spacedim, typename value_type>
value_type
max(const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const std::vector<value_type> &children_values);
} // namespace Coarsening
} // namespace AdaptationStrategies
template <int dim, int spacedim, typename value_type>
std::vector<value_type>
preserve(const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const value_type parent_value)
{
Assert(parent->n_children() > 0, ExcInternalError());
template <int dim, int spacedim, typename value_type>
std::vector<value_type>
split(const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const value_type parent_value)
{
static_assert(std::is_arithmetic_v<value_type> &&
template <int dim, int spacedim, typename value_type>
std::vector<value_type>
l2_norm(const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const value_type parent_value)
{
static_assert(std::is_arithmetic_v<value_type> &&
template <int dim, int spacedim, typename value_type>
value_type
mean(const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const std::vector<value_type> &children_values)
{
return sum<dim, spacedim, value_type>(parent, children_values) /
template <int dim, int spacedim, typename VectorType>
CellDataTransfer<dim, spacedim, VectorType>::CellDataTransfer(
- const Triangulation<dim, spacedim> & triangulation,
+ const Triangulation<dim, spacedim> &triangulation,
const std::function<std::vector<value_type>(
const typename Triangulation<dim, spacedim>::cell_iterator &parent,
const value_type parent_value)> refinement_strategy,
template <int dim, int spacedim, typename VectorType>
void
CellDataTransfer<dim, spacedim, VectorType>::unpack(const VectorType &in,
- VectorType & out)
+ VectorType &out)
{
#ifdef DEBUG
Assert(in.size() == n_active_cells_pre,
const dealii::hp::MappingCollection<dim, spacedim> &mapping,
const std::vector<
std::shared_ptr<dealii::hp::FECollection<dim, spacedim>>>
- & finite_elements,
+ &finite_elements,
const UpdateFlags update_flags,
const std::vector<std::vector<unsigned int>> &cell_to_patch_index_map);
void
set_cell_selection(
const std::function<cell_iterator(const Triangulation<dim, spacedim> &)>
- & first_cell,
+ &first_cell,
const std::function<cell_iterator(const Triangulation<dim, spacedim> &,
const cell_iterator &)> &next_cell);
* constructor assumes that no postprocessor is going to be used.
*/
DataEntryBase(const DoFHandler<dim, spacedim> *dofs,
- const std::vector<std::string> & names,
+ const std::vector<std::string> &names,
const std::vector<
DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretation);
* case, the names and vector declarations are going to be acquired from
* the postprocessor.
*/
- DataEntryBase(const DoFHandler<dim, spacedim> * dofs,
+ DataEntryBase(const DoFHandler<dim, spacedim> *dofs,
const DataPostprocessor<spacedim> *data_postprocessor);
/**
*/
virtual void
get_function_values(
- const FEValuesBase<dim, spacedim> & fe_patch_values,
+ const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
std::vector<dealii::Vector<double>> &patch_values_system) const = 0;
get_function_gradients(
const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
- std::vector<Tensor<1, spacedim>> & patch_gradients) const = 0;
+ std::vector<Tensor<1, spacedim>> &patch_gradients) const = 0;
/**
* Given a FEValuesBase object, extract the gradients on the present
get_function_hessians(
const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
- std::vector<Tensor<2, spacedim>> & patch_hessians) const = 0;
+ std::vector<Tensor<2, spacedim>> &patch_hessians) const = 0;
/**
* Given a FEValuesBase object, extract the second derivatives on the
const unsigned int n_datasets,
const unsigned int n_subdivisions,
const std::vector<unsigned int> &n_postprocessor_outputs,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const std::vector<
std::shared_ptr<dealii::hp::FECollection<dim, spacedim>>>
- & finite_elements,
+ &finite_elements,
const UpdateFlags update_flags,
const bool use_face_values);
const dealii::hp::MappingCollection<dim, spacedim> &mapping,
const std::vector<
std::shared_ptr<dealii::hp::FECollection<dim, spacedim>>>
- & finite_elements,
+ &finite_elements,
const UpdateFlags update_flags,
const bool use_face_values);
reinit_all_fe_values(
std::vector<std::shared_ptr<DataEntryBase<dim, spacedim>>> &dof_data,
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & cell,
+ &cell,
const unsigned int face = numbers::invalid_unsigned_int);
const FEValuesBase<dim, spacedim> &
template <typename VectorType>
void
add_data_vector(
- const VectorType & data,
+ const VectorType &data,
const std::vector<std::string> &names,
const DataVectorType type = type_automatic,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
template <typename VectorType>
void
add_data_vector(
- const VectorType & data,
- const std::string & name,
+ const VectorType &data,
+ const std::string &name,
const DataVectorType type = type_automatic,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretation = {});
void
add_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
- const VectorType & data,
- const std::vector<std::string> & names,
+ const VectorType &data,
+ const std::vector<std::string> &names,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretation = {});
void
add_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
- const VectorType & data,
- const std::string & name,
+ const VectorType &data,
+ const std::string &name,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretation = {});
*/
template <typename VectorType>
void
- add_data_vector(const VectorType & data,
+ add_data_vector(const VectorType &data,
const DataPostprocessor<spacedim> &data_postprocessor);
/**
*/
template <typename VectorType>
void
- add_data_vector(const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & data,
+ add_data_vector(const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &data,
const DataPostprocessor<spacedim> &data_postprocessor);
/**
add_mg_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
const MGLevelObject<VectorType> &data,
- const std::vector<std::string> & names,
+ const std::vector<std::string> &names,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretation = std::vector<
DataComponentInterpretation::DataComponentInterpretation>());
void
add_mg_data_vector(const DoFHandler<dim, spacedim> &dof_handler,
const MGLevelObject<VectorType> &data,
- const std::string & name);
+ const std::string &name);
/**
* Release the pointers to the data vectors. This allows output of a new set
void
add_data_vector_internal(
const DoFHandler<dim, spacedim> *dof_handler,
- const VectorType & data,
- const std::vector<std::string> & names,
+ const VectorType &data,
+ const std::vector<std::string> &names,
const DataVectorType type,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
- & data_component_interpretation,
+ &data_component_interpretation,
const bool deduce_output_names);
};
template <typename VectorType>
void
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::add_data_vector(
- const VectorType & vec,
- const std::string & name,
+ const VectorType &vec,
+ const std::string &name,
const DataVectorType type,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretation)
template <typename VectorType>
void
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::add_data_vector(
- const VectorType & vec,
+ const VectorType &vec,
const std::vector<std::string> &names,
const DataVectorType type,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
void
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::add_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
- const VectorType & data,
- const std::string & name,
+ const VectorType &data,
+ const std::string &name,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretation)
{
void
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::add_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
- const VectorType & data,
- const std::vector<std::string> & names,
+ const VectorType &data,
+ const std::vector<std::string> &names,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretation)
{
template <typename VectorType>
void
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::add_data_vector(
- const VectorType & vec,
+ const VectorType &vec,
const DataPostprocessor<spacedim> &data_postprocessor)
{
Assert(dofs != nullptr,
void
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::merge_patches(
const DataOut_DoFData<dim2, patch_dim, spacedim2, patch_spacedim> &source,
- const Point<patch_spacedim> & shift)
+ const Point<patch_spacedim> &shift)
{
const std::vector<Patch> &source_patches = source.get_patches();
Assert((patches.size() != 0) && (source_patches.size() != 0),
ParallelDataBase<dim, spacedim>::ParallelDataBase(
const unsigned int n_datasets,
const unsigned int n_subdivisions,
- const std::vector<unsigned int> & n_postprocessor_outputs,
+ const std::vector<unsigned int> &n_postprocessor_outputs,
const dealii::Mapping<dim, spacedim> &mapping,
const std::vector<
std::shared_ptr<dealii::hp::FECollection<dim, spacedim>>>
- & finite_elements,
+ &finite_elements,
const UpdateFlags update_flags,
const bool use_face_values)
: ParallelDataBase<dim, spacedim>(
generate_simplex_evaluation_points_recursively(
const std::vector<Point<2>> &bounding_vertices,
const unsigned int n_subdivisions,
- std::vector<Point<2>> & evaluation_points)
+ std::vector<Point<2>> &evaluation_points)
{
if (n_subdivisions == 0)
{
const dealii::hp::MappingCollection<dim, spacedim> &mapping_collection,
const std::vector<
std::shared_ptr<dealii::hp::FECollection<dim, spacedim>>>
- & finite_elements,
+ &finite_elements,
const UpdateFlags update_flags,
const bool use_face_values,
std::vector<std::shared_ptr<dealii::hp::FEValues<dim, spacedim>>>
// to test there if dim<3.
static const auto has_fe_with_reference_cell =
[](const dealii::hp::FECollection<dim, spacedim> &fe_collection,
- const ReferenceCell & reference_cell) {
+ const ReferenceCell &reference_cell) {
for (unsigned int i = 0; i < fe_collection.size(); ++i)
if (fe_collection[i].reference_cell() == reference_cell)
return true;
const dealii::hp::MappingCollection<dim, spacedim> &mapping,
const std::vector<
std::shared_ptr<dealii::hp::FECollection<dim, spacedim>>>
- & finite_elements,
+ &finite_elements,
const UpdateFlags update_flags,
const bool use_face_values)
: n_datasets(n_datasets)
template <int dim, int spacedim>
void
append_patch_to_list(
- const DataOutBase::Patch<dim, spacedim> & patch,
+ const DataOutBase::Patch<dim, spacedim> &patch,
std::vector<DataOutBase::Patch<dim, spacedim>> &patches)
{
patches.push_back(patch);
template <int dim, int spacedim>
DataEntryBase<dim, spacedim>::DataEntryBase(
const DoFHandler<dim, spacedim> *dofs,
- const std::vector<std::string> & names_in,
+ const std::vector<std::string> &names_in,
const std::vector<
DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretation)
template <int dim, int spacedim>
DataEntryBase<dim, spacedim>::DataEntryBase(
- const DoFHandler<dim, spacedim> * dofs,
+ const DoFHandler<dim, spacedim> *dofs,
const DataPostprocessor<spacedim> *data_postprocessor)
: dof_handler(
dofs,
template <typename VectorType, typename Number>
void
copy_locally_owned_data_from(
- const VectorType & src,
+ const VectorType &src,
LinearAlgebra::distributed::Vector<Number> &dst)
{
LinearAlgebra::ReadWriteVector<typename VectorType::value_type> temp;
template <typename Number>
void
copy_locally_owned_data_from(
- const TrilinosWrappers::MPI::Vector & src,
+ const TrilinosWrappers::MPI::Vector &src,
LinearAlgebra::distributed::Vector<Number> &dst)
{
// ReadWriteVector does not work for ghosted
* = nullptr>
void
create_dof_vector(
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & src,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &src,
LinearAlgebra::distributed::BlockVector<Number> &dst,
const unsigned int level = numbers::invalid_unsigned_int)
{
* = nullptr>
void
create_dof_vector(
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & src,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &src,
LinearAlgebra::distributed::BlockVector<Number> &dst,
const unsigned int level = numbers::invalid_unsigned_int)
{
std::enable_if_t<IsBlockVector<VectorType>::value, VectorType>
* = nullptr>
void
- create_cell_vector(const VectorType & src,
+ create_cell_vector(const VectorType &src,
LinearAlgebra::distributed::BlockVector<Number> &dst)
{
dst.reinit(src.n_blocks());
std::enable_if_t<!IsBlockVector<VectorType>::value, VectorType>
* = nullptr>
void
- create_cell_vector(const VectorType & src,
+ create_cell_vector(const VectorType &src,
LinearAlgebra::distributed::BlockVector<Number> &dst)
{
dst.reinit(1);
*/
template <typename DataVectorType, typename VectorType>
DataEntry(const DoFHandler<dim, spacedim> *dofs,
- const VectorType * data,
- const std::vector<std::string> & names,
+ const VectorType *data,
+ const std::vector<std::string> &names,
const std::vector<
DataComponentInterpretation::DataComponentInterpretation>
- & data_component_interpretation,
+ &data_component_interpretation,
const DataVectorType actual_type);
/**
* the postprocessor.
*/
template <typename VectorType>
- DataEntry(const DoFHandler<dim, spacedim> * dofs,
- const VectorType * data,
+ DataEntry(const DoFHandler<dim, spacedim> *dofs,
+ const VectorType *data,
const DataPostprocessor<spacedim> *data_postprocessor);
/**
get_function_gradients(
const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
- std::vector<Tensor<1, spacedim>> & patch_gradients) const override;
+ std::vector<Tensor<1, spacedim>> &patch_gradients) const override;
/**
* Given a FEValuesBase object, extract the gradients on the present
get_function_hessians(
const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
- std::vector<Tensor<2, spacedim>> & patch_hessians) const override;
+ std::vector<Tensor<2, spacedim>> &patch_hessians) const override;
/**
* Given a FEValuesBase object, extract the second derivatives on the
template <typename DataVectorType, typename VectorType>
DataEntry<dim, spacedim, ScalarType>::DataEntry(
const DoFHandler<dim, spacedim> *dofs,
- const VectorType * data,
- const std::vector<std::string> & names,
+ const VectorType *data,
+ const std::vector<std::string> &names,
const std::vector<
DataComponentInterpretation::DataComponentInterpretation>
- & data_component_interpretation,
+ &data_component_interpretation,
const DataVectorType actual_type)
: DataEntryBase<dim, spacedim>(dofs, names, data_component_interpretation)
{
template <int dim, int spacedim, typename ScalarType>
template <typename VectorType>
DataEntry<dim, spacedim, ScalarType>::DataEntry(
- const DoFHandler<dim, spacedim> * dofs,
- const VectorType * data,
+ const DoFHandler<dim, spacedim> *dofs,
+ const VectorType *data,
const DataPostprocessor<spacedim> *data_postprocessor)
: DataEntryBase<dim, spacedim>(dofs, data_postprocessor)
{
template <int dim, int spacedim, typename ScalarType>
void
DataEntry<dim, spacedim, ScalarType>::get_function_values(
- const FEValuesBase<dim, spacedim> & fe_patch_values,
+ const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
std::vector<dealii::Vector<double>> &patch_values_system) const
{
DataEntry<dim, spacedim, ScalarType>::get_function_values(
const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
- std::vector<double> & patch_values) const
+ std::vector<double> &patch_values) const
{
if constexpr (std::is_same_v<ScalarType, double>)
{
template <int dim, int spacedim, typename ScalarType>
void
DataEntry<dim, spacedim, ScalarType>::get_function_gradients(
- const FEValuesBase<dim, spacedim> & fe_patch_values,
+ const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
std::vector<std::vector<Tensor<1, spacedim>>> &patch_gradients_system)
const
DataEntry<dim, spacedim, ScalarType>::get_function_gradients(
const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
- std::vector<Tensor<1, spacedim>> & patch_gradients) const
+ std::vector<Tensor<1, spacedim>> &patch_gradients) const
{
if constexpr (std::is_same_v<ScalarType, double>)
{
template <int dim, int spacedim, typename ScalarType>
void
DataEntry<dim, spacedim, ScalarType>::get_function_hessians(
- const FEValuesBase<dim, spacedim> & fe_patch_values,
+ const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
std::vector<std::vector<Tensor<2, spacedim>>> &patch_hessians_system)
const
DataEntry<dim, spacedim, ScalarType>::get_function_hessians(
const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
- std::vector<Tensor<2, spacedim>> & patch_hessians) const
+ std::vector<Tensor<2, spacedim>> &patch_hessians) const
{
if constexpr (std::is_same_v<ScalarType, double>)
{
template <typename VectorType>
MGDataEntry(const DoFHandler<dim, spacedim> *dofs,
const MGLevelObject<VectorType> *vectors,
- const std::vector<std::string> & names,
+ const std::vector<std::string> &names,
const std::vector<
DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretation)
extract(const LinearAlgebra::distributed::BlockVector<ScalarType> &vector,
const std::vector<types::global_dof_index> &indices,
const ComponentExtractor extract_component,
- std::vector<double> & values) const
+ std::vector<double> &values) const
{
for (unsigned int i = 0; i < values.size(); ++i)
values[i] = get_component(vector[indices[i]], extract_component);
MGDataEntry<dim, spacedim, ScalarType>::get_function_values(
const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
- std::vector<double> & patch_values) const
+ std::vector<double> &patch_values) const
{
Assert(extract_component == ComponentExtractor::real_part,
ExcNotImplemented());
template <int dim, int spacedim, typename ScalarType>
void
MGDataEntry<dim, spacedim, ScalarType>::get_function_values(
- const FEValuesBase<dim, spacedim> & fe_patch_values,
+ const FEValuesBase<dim, spacedim> &fe_patch_values,
const ComponentExtractor extract_component,
std::vector<dealii::Vector<double>> &patch_values_system) const
{
template <typename VectorType>
void
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::add_data_vector(
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & vec,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &vec,
const DataPostprocessor<spacedim> &data_postprocessor)
{
// this is a specialized version of the other function where we have a
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::
add_data_vector_internal(
const DoFHandler<dim, spacedim> *dof_handler,
- const VectorType & data_vector,
- const std::vector<std::string> & names,
+ const VectorType &data_vector,
+ const std::vector<std::string> &names,
const DataVectorType type,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
- & data_component_interpretation_,
+ &data_component_interpretation_,
const bool deduce_output_names)
{
// Check available mesh information:
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::add_mg_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
const MGLevelObject<VectorType> &data,
- const std::string & name)
+ const std::string &name)
{
// forward the call to the vector version:
std::vector<std::string> names(1, name);
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::add_mg_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
const MGLevelObject<VectorType> &data,
- const std::vector<std::string> & names,
+ const std::vector<std::string> &names,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretation_)
{
ParallelData(const unsigned int n_datasets,
const unsigned int n_subdivisions,
const std::vector<unsigned int> &n_postprocessor_outputs,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const std::vector<
std::shared_ptr<dealii::hp::FECollection<dim, spacedim>>>
- & finite_elements,
+ &finite_elements,
const UpdateFlags update_flags);
std::vector<Point<spacedim>> patch_evaluation_points;
build_one_patch(
const FaceDescriptor *cell_and_face,
internal::DataOutFacesImplementation::ParallelData<dim, spacedim> &data,
- DataOutBase::Patch<patch_dim, patch_spacedim> & patch);
+ DataOutBase::Patch<patch_dim, patch_spacedim> &patch);
};
* should be generated.
*/
DataOutResample(const Triangulation<patch_dim, spacedim> &patch_tria,
- const Mapping<patch_dim, spacedim> & patch_mapping);
+ const Mapping<patch_dim, spacedim> &patch_mapping);
/**
* Update the @p mapping of original triangulation. One needs to call this
const unsigned int n_subdivisions,
const unsigned int n_patches_per_circle,
const std::vector<unsigned int> &n_postprocessor_outputs,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const std::vector<
std::shared_ptr<dealii::hp::FECollection<dim, spacedim>>>
- & finite_elements,
+ &finite_elements,
const UpdateFlags update_flags);
const unsigned int n_patches_per_circle;
*/
void
build_one_patch(
- const cell_iterator * cell,
+ const cell_iterator *cell,
internal::DataOutRotationImplementation::ParallelData<dim, spacedim> &data,
std::vector<DataOutBase::Patch<patch_dim, patch_spacedim>> &my_patches);
};
*/
template <typename number>
void
- add_data_vector(const Vector<number> & vec,
+ add_data_vector(const Vector<number> &vec,
const std::vector<std::string> &names);
/**
*/
template <int dim, class InputVector, int spacedim>
void
- approximate_gradient(const Mapping<dim, spacedim> & mapping,
+ approximate_gradient(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const InputVector & solution,
- Vector<float> & derivative_norm,
+ const InputVector &solution,
+ Vector<float> &derivative_norm,
const unsigned int component = 0);
/**
template <int dim, class InputVector, int spacedim>
void
approximate_gradient(const DoFHandler<dim, spacedim> &dof,
- const InputVector & solution,
- Vector<float> & derivative_norm,
+ const InputVector &solution,
+ Vector<float> &derivative_norm,
const unsigned int component = 0);
/**
*/
template <int dim, class InputVector, int spacedim>
void
- approximate_second_derivative(const Mapping<dim, spacedim> & mapping,
+ approximate_second_derivative(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const InputVector & solution,
- Vector<float> & derivative_norm,
+ const InputVector &solution,
+ Vector<float> &derivative_norm,
const unsigned int component = 0);
/**
template <int dim, class InputVector, int spacedim>
void
approximate_second_derivative(const DoFHandler<dim, spacedim> &dof,
- const InputVector & solution,
- Vector<float> & derivative_norm,
+ const InputVector &solution,
+ Vector<float> &derivative_norm,
const unsigned int component = 0);
/**
template <int dim, int spacedim, class InputVector, int order>
void
approximate_derivative_tensor(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const InputVector & solution,
+ const InputVector &solution,
#ifndef _MSC_VER
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
#else
void
approximate_derivative_tensor(
const DoFHandler<dim, spacedim> &dof,
- const InputVector & solution,
+ const InputVector &solution,
#ifndef _MSC_VER
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
#else
* One output file with the name <tt>basename.[step].[suffix]</tt> will be
* produced for each iteration step.
*/
- DoFPrintSolverStep(SolverControl & control,
+ DoFPrintSolverStep(SolverControl &control,
VectorMemory<VectorType> &mem,
- DataOut<dim> & data_out,
- const std::string & basename);
+ DataOut<dim> &data_out,
+ const std::string &basename);
/**
* Call-back function for the iterative method.
*/
virtual void
print_vectors(const unsigned int step,
- const VectorType & x,
- const VectorType & r,
- const VectorType & d) const;
+ const VectorType &x,
+ const VectorType &r,
+ const VectorType &d) const;
private:
/**
template <int dim, typename SolverType, typename VectorType>
DoFPrintSolverStep<dim, SolverType, VectorType>::DoFPrintSolverStep(
- SolverControl & control,
+ SolverControl &control,
VectorMemory<VectorType> &mem,
- DataOut<dim> & data_out,
- const std::string & basename)
+ DataOut<dim> &data_out,
+ const std::string &basename)
: SolverType(control, mem)
, out(data_out)
, basename(basename)
void
DoFPrintSolverStep<dim, SolverType, VectorType>::print_vectors(
const unsigned int step,
- const VectorType & x,
- const VectorType & r,
- const VectorType & d) const
+ const VectorType &x,
+ const VectorType &r,
+ const VectorType &d) const
{
out.clear_data_vectors();
out.add_data_vector(x, "solution");
template <typename Number>
static void
estimate(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask = {},
+ Vector<float> &error,
+ const ComponentMask &component_mask = {},
const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
static void
estimate(
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask = {},
+ Vector<float> &error,
+ const ComponentMask &component_mask = {},
const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
template <typename Number>
static void
estimate(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask = {},
- const Function<spacedim> * coefficients = nullptr,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask = {},
+ const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
const types::material_id material_id = numbers::invalid_material_id,
static void
estimate(
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask = {},
- const Function<spacedim> * coefficients = nullptr,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask = {},
+ const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
const types::material_id material_id = numbers::invalid_material_id,
template <typename Number>
static void
estimate(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask = {},
+ Vector<float> &error,
+ const ComponentMask &component_mask = {},
const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
static void
estimate(
const DoFHandler<dim, spacedim> &dof,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask = {},
+ Vector<float> &error,
+ const ComponentMask &component_mask = {},
const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
template <typename Number>
static void
estimate(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask = {},
- const Function<spacedim> * coefficients = nullptr,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask = {},
+ const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
const types::material_id material_id = numbers::invalid_material_id,
static void
estimate(
const DoFHandler<dim, spacedim> &dof,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask = {},
- const Function<spacedim> * coefficients = nullptr,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask = {},
+ const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
const types::material_id material_id = numbers::invalid_material_id,
template <typename Number>
static void
estimate(
- const Mapping<1, spacedim> & mapping,
+ const Mapping<1, spacedim> &mapping,
const DoFHandler<1, spacedim> &dof,
- const Quadrature<0> & quadrature,
+ const Quadrature<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask = {},
+ Vector<float> &error,
+ const ComponentMask &component_mask = {},
const Function<spacedim> *coefficient = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
static void
estimate(
const DoFHandler<1, spacedim> &dof,
- const Quadrature<0> & quadrature,
+ const Quadrature<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask = {},
+ Vector<float> &error,
+ const ComponentMask &component_mask = {},
const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
template <typename Number>
static void
estimate(
- const Mapping<1, spacedim> & mapping,
+ const Mapping<1, spacedim> &mapping,
const DoFHandler<1, spacedim> &dof,
- const Quadrature<0> & quadrature,
+ const Quadrature<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask = {},
- const Function<spacedim> * coefficients = nullptr,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask = {},
+ const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
const types::material_id material_id = numbers::invalid_material_id,
static void
estimate(
const DoFHandler<1, spacedim> &dof,
- const Quadrature<0> & quadrature,
+ const Quadrature<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask = {},
- const Function<spacedim> * coefficients = nullptr,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask = {},
+ const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
const types::material_id material_id = numbers::invalid_material_id,
template <typename Number>
static void
estimate(
- const Mapping<1, spacedim> & mapping,
+ const Mapping<1, spacedim> &mapping,
const DoFHandler<1, spacedim> &dof,
- const hp::QCollection<0> & quadrature,
+ const hp::QCollection<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask = {},
+ Vector<float> &error,
+ const ComponentMask &component_mask = {},
const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
static void
estimate(
const DoFHandler<1, spacedim> &dof,
- const hp::QCollection<0> & quadrature,
+ const hp::QCollection<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask = {},
+ Vector<float> &error,
+ const ComponentMask &component_mask = {},
const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
template <typename Number>
static void
estimate(
- const Mapping<1, spacedim> & mapping,
+ const Mapping<1, spacedim> &mapping,
const DoFHandler<1, spacedim> &dof,
- const hp::QCollection<0> & quadrature,
+ const hp::QCollection<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask = {},
- const Function<spacedim> * coefficients = nullptr,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask = {},
+ const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
const types::material_id material_id = numbers::invalid_material_id,
static void
estimate(
const DoFHandler<1, spacedim> &dof,
- const hp::QCollection<0> & quadrature,
+ const hp::QCollection<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask = {},
- const Function<spacedim> * coefficients = nullptr,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask = {},
+ const Function<spacedim> *coefficients = nullptr,
const unsigned int n_threads = numbers::invalid_unsigned_int,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
const types::material_id material_id = numbers::invalid_material_id,
* KellyErrorEstimator::estimate() function.
*/
const std::map<types::boundary_id, const Function<spacedim, number> *>
- * neumann_bc;
+ *neumann_bc;
const ComponentMask component_mask;
const Function<spacedim> *coefficients;
* Constructor.
*/
template <class FE>
- ParallelData(const FE & fe,
+ ParallelData(const FE &fe,
const dealii::hp::QCollection<dim - 1> &face_quadratures,
const dealii::hp::MappingCollection<dim, spacedim> &mapping,
const bool need_quadrature_points,
const types::material_id material_id,
const std::map<types::boundary_id,
const Function<spacedim, number> *> *neumann_bc,
- const ComponentMask & component_mask,
+ const ComponentMask &component_mask,
const Function<spacedim> *coefficients);
/**
template <int dim, int spacedim, typename number>
template <class FE>
ParallelData<dim, spacedim, number>::ParallelData(
- const FE & fe,
- const dealii::hp::QCollection<dim - 1> & face_quadratures,
+ const FE &fe,
+ const dealii::hp::QCollection<dim - 1> &face_quadratures,
const dealii::hp::MappingCollection<dim, spacedim> &mapping,
const bool need_quadrature_points,
const unsigned int n_solution_vectors,
const types::subdomain_id subdomain_id,
const types::material_id material_id,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- * neumann_bc,
- const ComponentMask & component_mask,
+ *neumann_bc,
+ const ComponentMask &component_mask,
const Function<spacedim> *coefficients)
: finite_element(fe)
, face_quadratures(face_quadratures)
const std::map<typename DoFHandler<dim, spacedim>::face_iterator,
std::vector<double>> &local_face_integrals,
std::map<typename DoFHandler<dim, spacedim>::face_iterator,
- std::vector<double>> & face_integrals)
+ std::vector<double>> &face_integrals)
{
// now copy locally computed elements into the global map
for (typename std::map<typename DoFHandler<dim, spacedim>::face_iterator,
template <int dim, int spacedim, typename number>
std::vector<double>
integrate_over_face(
- ParallelData<dim, spacedim, number> & parallel_data,
+ ParallelData<dim, spacedim, number> ¶llel_data,
const typename DoFHandler<dim, spacedim>::face_iterator &face,
dealii::hp::FEFaceValues<dim, spacedim> &fe_face_values_cell)
{
irregular_face_factor(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & neighbor_child,
+ &neighbor_child,
const unsigned int face_no,
const unsigned int subface_no,
const dealii::hp::FEFaceValues<dim, spacedim> &fe_face_values,
- dealii::hp::FESubfaceValues<dim, spacedim> & fe_subface_values,
+ dealii::hp::FESubfaceValues<dim, spacedim> &fe_subface_values,
const typename KellyErrorEstimator<dim, spacedim>::Strategy strategy)
{
switch (strategy)
void
integrate_over_regular_face(
const ArrayView<const ReadVector<Number> *> &solutions,
- ParallelData<dim, spacedim, Number> & parallel_data,
+ ParallelData<dim, spacedim, Number> ¶llel_data,
std::map<typename DoFHandler<dim, spacedim>::face_iterator,
- std::vector<double>> & local_face_integrals,
+ std::vector<double>> &local_face_integrals,
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const unsigned int face_no,
dealii::hp::FEFaceValues<dim, spacedim> &fe_face_values_cell,
void
integrate_over_irregular_face(
const ArrayView<const ReadVector<Number> *> &solutions,
- ParallelData<dim, spacedim, Number> & parallel_data,
+ ParallelData<dim, spacedim, Number> ¶llel_data,
std::map<typename DoFHandler<dim, spacedim>::face_iterator,
- std::vector<double>> & local_face_integrals,
+ std::vector<double>> &local_face_integrals,
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const unsigned int face_no,
- dealii::hp::FEFaceValues<dim, spacedim> & fe_face_values,
+ dealii::hp::FEFaceValues<dim, spacedim> &fe_face_values,
dealii::hp::FESubfaceValues<dim, spacedim> &fe_subface_values,
const typename KellyErrorEstimator<dim, spacedim>::Strategy strategy)
{
void
estimate_one_cell(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
- ParallelData<dim, spacedim, Number> & parallel_data,
+ ParallelData<dim, spacedim, Number> ¶llel_data,
std::map<typename DoFHandler<dim, spacedim>::face_iterator,
- std::vector<double>> & local_face_integrals,
+ std::vector<double>> &local_face_integrals,
const ArrayView<const ReadVector<Number> *> &solutions,
const typename KellyErrorEstimator<dim, spacedim>::Strategy strategy)
{
template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask,
+ Vector<float> &error,
+ const ComponentMask &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
void
KellyErrorEstimator<dim, spacedim>::estimate(
const DoFHandler<dim, spacedim> &dof_handler,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask,
+ Vector<float> &error,
+ const ComponentMask &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask,
+ Vector<float> &error,
+ const ComponentMask &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
void
KellyErrorEstimator<dim, spacedim>::estimate(
const DoFHandler<dim, spacedim> &dof_handler,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask,
+ Vector<float> &error,
+ const ComponentMask &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const hp::QCollection<dim - 1> & face_quadratures,
+ const hp::QCollection<dim - 1> &face_quadratures,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask,
+ const Function<spacedim> *coefficients,
const unsigned int,
const types::subdomain_id subdomain_id_,
const types::material_id material_id,
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
internal::ParallelData<dim, spacedim, Number> ¶llel_data,
std::map<typename DoFHandler<dim, spacedim>::face_iterator,
- std::vector<double>> & local_face_integrals) {
+ std::vector<double>> &local_face_integrals) {
internal::estimate_one_cell(
cell, parallel_data, local_face_integrals, solutions, strategy);
},
template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask,
+ const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
const types::material_id material_id,
void
KellyErrorEstimator<dim, spacedim>::estimate(
const DoFHandler<dim, spacedim> &dof_handler,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask,
+ const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
const types::material_id material_id,
void
KellyErrorEstimator<dim, spacedim>::estimate(
const DoFHandler<dim, spacedim> &dof_handler,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask,
+ const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
const types::material_id material_id,
*/
FEFieldFunction(
const DoFHandler<dim, spacedim> &dh,
- const VectorType & data_vector,
- const Mapping<dim> & mapping = StaticMappingQ1<dim>::mapping);
+ const VectorType &data_vector,
+ const Mapping<dim> &mapping = StaticMappingQ1<dim>::mapping);
/**
* Set the current cell. If you know in advance where your points lie, you
*/
virtual void
vector_value(
- const Point<dim> & p,
+ const Point<dim> &p,
Vector<typename VectorType::value_type> &values) const override;
/**
* information.
*/
virtual void
- value_list(const std::vector<Point<dim>> & points,
+ value_list(const std::vector<Point<dim>> &points,
std::vector<typename VectorType::value_type> &values,
const unsigned int component = 0) const override;
* information.
*/
virtual Tensor<1, dim, typename VectorType::value_type>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
*/
virtual void
gradient_list(
- const std::vector<Point<dim>> & p,
+ const std::vector<Point<dim>> &p,
std::vector<Tensor<1, dim, typename VectorType::value_type>> &gradients,
const unsigned int component = 0) const override;
* information.
*/
virtual typename VectorType::value_type
- laplacian(const Point<dim> & p,
+ laplacian(const Point<dim> &p,
const unsigned int component = 0) const override;
/**
*/
virtual void
vector_laplacian(
- const Point<dim> & p,
+ const Point<dim> &p,
Vector<typename VectorType::value_type> &values) const override;
/**
* information.
*/
virtual void
- laplacian_list(const std::vector<Point<dim>> & points,
+ laplacian_list(const std::vector<Point<dim>> &points,
std::vector<typename VectorType::value_type> &values,
const unsigned int component = 0) const override;
compute_point_locations(
const std::vector<Point<dim>> &points,
std::vector<typename DoFHandler<dim, spacedim>::active_cell_iterator>
- & cells,
- std::vector<std::vector<Point<dim>>> & qpoints,
+ &cells,
+ std::vector<std::vector<Point<dim>>> &qpoints,
std::vector<std::vector<unsigned int>> &maps) const;
private:
template <int dim, typename VectorType, int spacedim>
FEFieldFunction<dim, VectorType, spacedim>::FEFieldFunction(
const DoFHandler<dim, spacedim> &mydh,
- const VectorType & myv,
- const Mapping<dim> & mymapping)
+ const VectorType &myv,
+ const Mapping<dim> &mymapping)
: Function<dim, typename VectorType::value_type>(
mydh.get_fe(0).n_components())
, dh(&mydh, "FEFieldFunction")
template <int dim, typename VectorType, int spacedim>
void
FEFieldFunction<dim, VectorType, spacedim>::vector_value(
- const Point<dim> & p,
+ const Point<dim> &p,
Vector<typename VectorType::value_type> &values) const
{
Assert(values.size() == this->n_components,
template <int dim, typename VectorType, int spacedim>
typename VectorType::value_type
FEFieldFunction<dim, VectorType, spacedim>::value(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int comp) const
{
Vector<typename VectorType::value_type> values(this->n_components);
template <int dim, typename VectorType, int spacedim>
void
FEFieldFunction<dim, VectorType, spacedim>::vector_gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
std::vector<Tensor<1, dim, typename VectorType::value_type>> &gradients)
const
{
template <int dim, typename VectorType, int spacedim>
Tensor<1, dim, typename VectorType::value_type>
FEFieldFunction<dim, VectorType, spacedim>::gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int comp) const
{
std::vector<Tensor<1, dim, typename VectorType::value_type>> grads(
template <int dim, typename VectorType, int spacedim>
void
FEFieldFunction<dim, VectorType, spacedim>::vector_laplacian(
- const Point<dim> & p,
+ const Point<dim> &p,
Vector<typename VectorType::value_type> &values) const
{
Assert(values.size() == this->n_components,
template <int dim, typename VectorType, int spacedim>
typename VectorType::value_type
FEFieldFunction<dim, VectorType, spacedim>::laplacian(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int comp) const
{
Vector<typename VectorType::value_type> lap(this->n_components);
template <int dim, typename VectorType, int spacedim>
void
FEFieldFunction<dim, VectorType, spacedim>::vector_value_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Vector<typename VectorType::value_type>> &values) const
{
Assert(points.size() == values.size(),
template <int dim, typename VectorType, int spacedim>
void
FEFieldFunction<dim, VectorType, spacedim>::value_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<typename VectorType::value_type> &values,
const unsigned int component) const
{
template <int dim, typename VectorType, int spacedim>
void
FEFieldFunction<dim, VectorType, spacedim>::gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Tensor<1, dim, typename VectorType::value_type>> &values,
const unsigned int component) const
{
template <int dim, typename VectorType, int spacedim>
void
FEFieldFunction<dim, VectorType, spacedim>::vector_laplacian_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<Vector<typename VectorType::value_type>> &values) const
{
Assert(points.size() == values.size(),
template <int dim, typename VectorType, int spacedim>
void
FEFieldFunction<dim, VectorType, spacedim>::laplacian_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<typename VectorType::value_type> &values,
const unsigned int component) const
{
FEFieldFunction<dim, VectorType, spacedim>::compute_point_locations(
const std::vector<Point<dim>> &points,
std::vector<typename DoFHandler<dim, spacedim>::active_cell_iterator>
- & cells,
- std::vector<std::vector<Point<dim>>> & qpoints,
+ &cells,
+ std::vector<std::vector<Point<dim>>> &qpoints,
std::vector<std::vector<unsigned int>> &maps) const
{
// Calling the GridTools routine and preparing output
std::optional<Point<dim>>
FEFieldFunction<dim, VectorType, spacedim>::get_reference_coordinates(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
- const Point<dim> & point) const
+ const Point<dim> &point) const
{
try
{
template <typename number>
void
evaluate(const std::vector<Vector<number>> &values,
- const std::vector<double> & y_values,
+ const std::vector<double> &y_values,
const unsigned int n_intervals,
const IntervalSpacing interval_spacing = linear);
template <int dim, int spacedim, typename SparseMatrixType>
void
create_mass_matrix(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
void
create_mass_matrix(
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
template <int dim, int spacedim, typename SparseMatrixType>
void
create_mass_matrix(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
template <int dim, int spacedim, typename SparseMatrixType>
void
create_mass_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
void
create_mass_matrix(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
void
create_mass_matrix(
const DoFHandler<dim, spacedim> &dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
template <int dim, int spacedim, typename SparseMatrixType>
void
create_mass_matrix(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
template <int dim, int spacedim, typename SparseMatrixType>
void
create_mass_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
template <int dim, int spacedim, typename number>
void
create_boundary_mass_matrix(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim - 1> & q,
- SparseMatrix<number> & matrix,
+ const Quadrature<dim - 1> &q,
+ SparseMatrix<number> &matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ &boundary_functions,
+ Vector<number> &rhs_vector,
+ std::vector<types::global_dof_index> &dof_to_boundary_mapping,
const Function<spacedim, number> *const weight = 0,
std::vector<unsigned int> component_mapping = {});
void
create_boundary_mass_matrix(
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim - 1> & q,
- SparseMatrix<number> & matrix,
+ const Quadrature<dim - 1> &q,
+ SparseMatrix<number> &matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ &boundary_functions,
+ Vector<number> &rhs_vector,
+ std::vector<types::global_dof_index> &dof_to_boundary_mapping,
const Function<spacedim, number> *const a = nullptr,
std::vector<unsigned int> component_mapping = {});
void
create_boundary_mass_matrix(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim - 1> & q,
- SparseMatrix<number> & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim - 1> &q,
+ SparseMatrix<number> &matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ &boundary_functions,
+ Vector<number> &rhs_vector,
+ std::vector<types::global_dof_index> &dof_to_boundary_mapping,
const Function<spacedim, number> *const a = nullptr,
std::vector<unsigned int> component_mapping = {});
void
create_boundary_mass_matrix(
const DoFHandler<dim, spacedim> &dof,
- const hp::QCollection<dim - 1> & q,
- SparseMatrix<number> & matrix,
+ const hp::QCollection<dim - 1> &q,
+ SparseMatrix<number> &matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ &boundary_functions,
+ Vector<number> &rhs_vector,
+ std::vector<types::global_dof_index> &dof_to_boundary_mapping,
const Function<spacedim, number> *const a = nullptr,
std::vector<unsigned int> component_mapping = {});
template <int dim, int spacedim, typename SparseMatrixType>
void
create_laplace_matrix(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
void
create_laplace_matrix(
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
template <int dim, int spacedim, typename SparseMatrixType>
void
create_laplace_matrix(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
template <int dim, int spacedim, typename SparseMatrixType>
void
create_laplace_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
void
create_laplace_matrix(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
void
create_laplace_matrix(
const DoFHandler<dim, spacedim> &dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
template <int dim, int spacedim, typename SparseMatrixType>
void
create_laplace_matrix(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
template <int dim, int spacedim, typename SparseMatrixType>
void
create_laplace_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type> *const a =
nullptr,
const AffineConstraints<typename SparseMatrixType::value_type> &
{
Scratch(const ::dealii::hp::FECollection<dim, spacedim> &fe,
const UpdateFlags update_flags,
- const Function<spacedim, number> * coefficient,
- const Function<spacedim, number> * rhs_function,
- const ::dealii::hp::QCollection<dim> & quadrature,
+ const Function<spacedim, number> *coefficient,
+ const Function<spacedim, number> *rhs_function,
+ const ::dealii::hp::QCollection<dim> &quadrature,
const ::dealii::hp::MappingCollection<dim, spacedim> &mapping)
: fe_collection(fe)
, quadrature_collection(quadrature)
const ::dealii::hp::FECollection<dim, spacedim> &fe_collection;
- const ::dealii::hp::QCollection<dim> & quadrature_collection;
+ const ::dealii::hp::QCollection<dim> &quadrature_collection;
const ::dealii::hp::MappingCollection<dim, spacedim>
&mapping_collection;
std::vector<types::global_dof_index> dof_indices;
FullMatrix<number> cell_matrix;
dealii::Vector<number> cell_rhs;
- const AffineConstraints<number> * constraints;
+ const AffineConstraints<number> *constraints;
bool is_locally_owned;
};
} // namespace AssemblerData
mass_assembler(
const CellIterator &cell,
MatrixCreator::internal::AssemblerData::Scratch<dim, spacedim, number>
- & data,
+ &data,
MatrixCreator::internal::AssemblerData::CopyData<number> ©_data)
{
copy_data.is_locally_owned = cell->is_locally_owned();
laplace_assembler(
const CellIterator &cell,
MatrixCreator::internal::AssemblerData::Scratch<dim, spacedim, Number>
- & data,
+ &data,
MatrixCreator::internal::AssemblerData::CopyData<Number> ©_data)
{
copy_data.is_locally_owned = cell->is_locally_owned();
template <typename number, typename MatrixType, typename VectorType>
void
copy_local_to_global(const AssemblerData::CopyData<number> &data,
- MatrixType * matrix,
- VectorType * right_hand_side)
+ MatrixType *matrix,
+ VectorType *right_hand_side)
{
if (data.is_locally_owned == false)
return;
template <int dim, int spacedim, typename SparseMatrixType>
void
create_mass_matrix(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
Assert(matrix.n() == dof.n_dofs(),
ExcDimensionMismatch(matrix.n(), dof.n_dofs()));
- const auto & fe_collection = dof.get_fe_collection();
+ const auto &fe_collection = dof.get_fe_collection();
hp::QCollection<dim> q_collection(q);
hp::MappingCollection<dim, spacedim> mapping_collection(mapping);
MatrixCreator::internal::AssemblerData::
void
create_mass_matrix(
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
template <int dim, int spacedim, typename SparseMatrixType>
void
create_mass_matrix(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
Assert(matrix.n() == dof.n_dofs(),
ExcDimensionMismatch(matrix.n(), dof.n_dofs()));
- const auto & fe_collection = dof.get_fe_collection();
+ const auto &fe_collection = dof.get_fe_collection();
hp::QCollection<dim> q_collection(q);
hp::MappingCollection<dim, spacedim> mapping_collection(mapping);
MatrixCreator::internal::AssemblerData::
template <int dim, int spacedim, typename SparseMatrixType>
void
create_mass_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
void
create_mass_matrix(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
void
create_mass_matrix(
const DoFHandler<dim, spacedim> &dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
template <int dim, int spacedim, typename SparseMatrixType>
void
create_mass_matrix(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
template <int dim, int spacedim, typename SparseMatrixType>
void
create_mass_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const MatrixCreator::internal::AssemblerBoundary::Scratch &,
MatrixCreator::internal::AssemblerBoundary::
- CopyData<dim, spacedim, number> & copy_data,
- const Mapping<dim, spacedim> & mapping,
+ CopyData<dim, spacedim, number> ©_data,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & q,
+ const Quadrature<dim - 1> &q,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
+ &boundary_functions,
const Function<spacedim, number> *const coefficient,
- const std::vector<unsigned int> & component_mapping)
+ const std::vector<unsigned int> &component_mapping)
{
// Most assertions for this function are in the calling function
// before creating threads.
const MatrixCreator::internal::AssemblerBoundary::
CopyData<dim, spacedim, number> ©_data,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
+ &boundary_functions,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparseMatrix<number> & matrix,
- Vector<number> & rhs_vector)
+ SparseMatrix<number> &matrix,
+ Vector<number> &rhs_vector)
{
// now transfer cell matrix and vector to the whole boundary matrix
//
template <int dim, int spacedim, typename number>
void
create_boundary_mass_matrix(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim - 1> & q,
- SparseMatrix<number> & matrix,
+ const Quadrature<dim - 1> &q,
+ SparseMatrix<number> &matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ &boundary_functions,
+ Vector<number> &rhs_vector,
+ std::vector<types::global_dof_index> &dof_to_boundary_mapping,
const Function<spacedim, number> *const coefficient,
std::vector<unsigned int> component_mapping)
{
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const MatrixCreator::internal::AssemblerBoundary::Scratch &,
MatrixCreator::internal::AssemblerBoundary ::
- CopyData<dim, spacedim, number> & copy_data,
+ CopyData<dim, spacedim, number> ©_data,
const hp::MappingCollection<dim, spacedim> &mapping,
- const hp::FECollection<dim, spacedim> & fe_collection,
- const hp::QCollection<dim - 1> & q,
+ const hp::FECollection<dim, spacedim> &fe_collection,
+ const hp::QCollection<dim - 1> &q,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
+ &boundary_functions,
const Function<spacedim, number> *const coefficient,
- const std::vector<unsigned int> & component_mapping)
+ const std::vector<unsigned int> &component_mapping)
{
const unsigned int n_components = fe_collection.n_components();
const unsigned int n_function_components =
const MatrixCreator::internal::AssemblerBoundary ::
CopyData<dim, spacedim, number> ©_data,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
+ &boundary_functions,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparseMatrix<number> & matrix,
- Vector<number> & rhs_vector)
+ SparseMatrix<number> &matrix,
+ Vector<number> &rhs_vector)
{
// now transfer cell matrix and vector to the whole boundary matrix
//
void
create_boundary_mass_matrix(
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim - 1> & q,
- SparseMatrix<number> & matrix,
+ const Quadrature<dim - 1> &q,
+ SparseMatrix<number> &matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *> &rhs,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ Vector<number> &rhs_vector,
+ std::vector<types::global_dof_index> &dof_to_boundary_mapping,
const Function<spacedim, number> *const a,
std::vector<unsigned int> component_mapping)
{
void
create_boundary_mass_matrix(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim - 1> & q,
- SparseMatrix<number> & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim - 1> &q,
+ SparseMatrix<number> &matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ &boundary_functions,
+ Vector<number> &rhs_vector,
+ std::vector<types::global_dof_index> &dof_to_boundary_mapping,
const Function<spacedim, number> *const coefficient,
std::vector<unsigned int> component_mapping)
{
void
create_boundary_mass_matrix(
const DoFHandler<dim, spacedim> &dof,
- const hp::QCollection<dim - 1> & q,
- SparseMatrix<number> & matrix,
+ const hp::QCollection<dim - 1> &q,
+ SparseMatrix<number> &matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *> &rhs,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ Vector<number> &rhs_vector,
+ std::vector<types::global_dof_index> &dof_to_boundary_mapping,
const Function<spacedim, number> *const a,
std::vector<unsigned int> component_mapping)
{
template <int dim, int spacedim, typename SparseMatrixType>
void
create_laplace_matrix(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
Assert(matrix.n() == dof.n_dofs(),
ExcDimensionMismatch(matrix.n(), dof.n_dofs()));
- const auto & fe_collection = dof.get_fe_collection();
+ const auto &fe_collection = dof.get_fe_collection();
hp::QCollection<dim> q_collection(q);
hp::MappingCollection<dim, spacedim> mapping_collection(mapping);
MatrixCreator::internal::AssemblerData::
void
create_laplace_matrix(
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
template <int dim, int spacedim, typename SparseMatrixType>
void
create_laplace_matrix(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
Assert(matrix.n() == dof.n_dofs(),
ExcDimensionMismatch(matrix.n(), dof.n_dofs()));
- const auto & fe_collection = dof.get_fe_collection();
+ const auto &fe_collection = dof.get_fe_collection();
hp::QCollection<dim> q_collection(q);
hp::MappingCollection<dim, spacedim> mapping_collection(mapping);
MatrixCreator::internal::AssemblerData::
template <int dim, int spacedim, typename SparseMatrixType>
void
create_laplace_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
void
create_laplace_matrix(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
void
create_laplace_matrix(
const DoFHandler<dim, spacedim> &dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
template <int dim, int spacedim, typename SparseMatrixType>
void
create_laplace_matrix(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
template <int dim, int spacedim, typename SparseMatrixType>
void
create_laplace_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrixType & matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ SparseMatrixType &matrix,
const Function<spacedim, typename SparseMatrixType::value_type> &rhs,
- Vector<typename SparseMatrixType::value_type> & rhs_vector,
+ Vector<typename SparseMatrixType::value_type> &rhs_vector,
const Function<spacedim, typename SparseMatrixType::value_type>
*const coefficient,
const AffineConstraints<typename SparseMatrixType::value_type> &constraints)
void
apply_boundary_values(
const std::map<types::global_dof_index, number> &boundary_values,
- SparseMatrix<number> & matrix,
- Vector<number> & solution,
- Vector<number> & right_hand_side,
+ SparseMatrix<number> &matrix,
+ Vector<number> &solution,
+ Vector<number> &right_hand_side,
const bool eliminate_columns = true);
/**
void
apply_boundary_values(
const std::map<types::global_dof_index, number> &boundary_values,
- BlockSparseMatrix<number> & matrix,
- BlockVector<number> & solution,
- BlockVector<number> & right_hand_side,
+ BlockSparseMatrix<number> &matrix,
+ BlockVector<number> &solution,
+ BlockVector<number> &right_hand_side,
const bool eliminate_columns = true);
#ifdef DEAL_II_WITH_PETSC
void
apply_boundary_values(
const std::map<types::global_dof_index, PetscScalar> &boundary_values,
- PETScWrappers::MatrixBase & matrix,
- PETScWrappers::VectorBase & solution,
- PETScWrappers::VectorBase & right_hand_side,
+ PETScWrappers::MatrixBase &matrix,
+ PETScWrappers::VectorBase &solution,
+ PETScWrappers::VectorBase &right_hand_side,
const bool eliminate_columns = true);
/**
void
apply_boundary_values(
const std::map<types::global_dof_index, PetscScalar> &boundary_values,
- PETScWrappers::MPI::BlockSparseMatrix & matrix,
- PETScWrappers::MPI::BlockVector & solution,
- PETScWrappers::MPI::BlockVector & right_hand_side,
+ PETScWrappers::MPI::BlockSparseMatrix &matrix,
+ PETScWrappers::MPI::BlockVector &solution,
+ PETScWrappers::MPI::BlockVector &right_hand_side,
const bool eliminate_columns = true);
#endif
void
apply_boundary_values(
const std::map<types::global_dof_index, TrilinosScalar> &boundary_values,
- TrilinosWrappers::SparseMatrix & matrix,
- TrilinosWrappers::MPI::Vector & solution,
- TrilinosWrappers::MPI::Vector & right_hand_side,
+ TrilinosWrappers::SparseMatrix &matrix,
+ TrilinosWrappers::MPI::Vector &solution,
+ TrilinosWrappers::MPI::Vector &right_hand_side,
const bool eliminate_columns = true);
/**
void
apply_boundary_values(
const std::map<types::global_dof_index, TrilinosScalar> &boundary_values,
- TrilinosWrappers::BlockSparseMatrix & matrix,
- TrilinosWrappers::MPI::BlockVector & solution,
- TrilinosWrappers::MPI::BlockVector & right_hand_side,
+ TrilinosWrappers::BlockSparseMatrix &matrix,
+ TrilinosWrappers::MPI::BlockVector &solution,
+ TrilinosWrappers::MPI::BlockVector &right_hand_side,
const bool eliminate_columns = true);
#endif
void
local_apply_boundary_values(
const std::map<types::global_dof_index, number> &boundary_values,
- const std::vector<types::global_dof_index> & local_dof_indices,
- FullMatrix<number> & local_matrix,
- Vector<number> & local_rhs,
+ const std::vector<types::global_dof_index> &local_dof_indices,
+ FullMatrix<number> &local_matrix,
+ Vector<number> &local_rhs,
const bool eliminate_columns);
/**
* @param anderson_subspace_size Size of the Anderson acceleration
* subspace, use 0 to disable.
*/
- AdditionalData(const SolverType & solver_type = automatic,
+ AdditionalData(const SolverType &solver_type = automatic,
const SolutionStrategy &strategy = linesearch,
const unsigned int maximum_non_linear_iterations = 200,
const double function_tolerance = 1e-8,
* @param mpi_communicator MPI communicator used by the nonlinear solver.
*/
NonlinearSolverSelector(const AdditionalData &additional_data,
- const MPI_Comm & mpi_communicator);
+ const MPI_Comm &mpi_communicator);
/**
* Select a new nonlinear solver. All solver names used in this class are
void
set_data(
const typename TrilinosWrappers::NOXSolver<VectorType>::AdditionalData
- & additional_data,
+ &additional_data,
const Teuchos::RCP<Teuchos::ParameterList> ¶meters =
Teuchos::rcp(new Teuchos::ParameterList));
#endif
template <typename VectorType>
NonlinearSolverSelector<VectorType>::NonlinearSolverSelector(
const AdditionalData &additional_data,
- const MPI_Comm & mpi_communicator)
+ const MPI_Comm &mpi_communicator)
: additional_data(additional_data)
, mpi_communicator(mpi_communicator)
{
template <typename VectorType>
NonlinearSolverSelector<VectorType>::AdditionalData::AdditionalData(
- const SolverType & solver_type,
+ const SolverType &solver_type,
const SolutionStrategy &strategy,
const unsigned int maximum_non_linear_iterations,
const double function_tolerance,
void
NonlinearSolverSelector<VectorType>::set_data(
const typename TrilinosWrappers::NOXSolver<VectorType>::AdditionalData
- & additional_data,
+ &additional_data,
const Teuchos::RCP<Teuchos::ParameterList> ¶meters)
{
additional_data_nox = additional_data;
nonlinear_solver.solve_with_jacobian =
[&](const PETScWrappers::MPI::Vector &src,
- PETScWrappers::MPI::Vector & dst) {
+ PETScWrappers::MPI::Vector &dst) {
// PETSc does not gives a tolerance, so we have to choose something
// reasonable to provide to the user:
const double tolerance = 1e-6;
* Only a constructor needed for this class (a struct really)
*/
PointGeometryData(
- const Point<dim> & new_requested_location,
- const std::vector<Point<dim>> & new_locations,
+ const Point<dim> &new_requested_location,
+ const std::vector<Point<dim>> &new_locations,
const std::vector<types::global_dof_index> &new_sol_indices);
Point<dim> requested_location;
std::vector<Point<dim>> support_point_locations;
* called in any order.
*/
void
- add_field_name(const std::string & vector_name,
+ add_field_name(const std::string &vector_name,
const ComponentMask &component_mask = {});
/**
* used instead of names generated from the field name, if supplied.
*/
void
- add_component_names(const std::string & vector_name,
+ add_component_names(const std::string &vector_name,
const std::vector<std::string> &component_names);
/**
template <typename VectorType>
void
evaluate_field(const std::vector<std::string> &names,
- const VectorType & solution,
- const DataPostprocessor<dim> & data_postprocessor,
- const Quadrature<dim> & quadrature);
+ const VectorType &solution,
+ const DataPostprocessor<dim> &data_postprocessor,
+ const Quadrature<dim> &quadrature);
/**
* Construct a std::vector <std::string> containing only vector_name and
*/
template <typename VectorType>
void
- evaluate_field(const std::string & name,
- const VectorType & solution,
+ evaluate_field(const std::string &name,
+ const VectorType &solution,
const DataPostprocessor<dim> &data_postprocessor,
- const Quadrature<dim> & quadrature);
+ const Quadrature<dim> &quadrature);
/**
template <typename VectorType>
void
evaluate_field_at_requested_location(const std::string &name,
- const VectorType & solution);
+ const VectorType &solution);
/**
* locations output.
*/
void
- write_gnuplot(const std::string & base_name,
+ write_gnuplot(const std::string &base_name,
const std::vector<Point<dim>> &postprocessor_locations =
std::vector<Point<dim>>());
* correct number of points by the method.
*/
void
- get_postprocessor_locations(const Quadrature<dim> & quadrature,
+ get_postprocessor_locations(const Quadrature<dim> &quadrature,
std::vector<Point<dim>> &locations);
/**
* @p target_level of the tree.
*/
inline ExtractLevelVisitor(
- const Translator & translator,
+ const Translator &translator,
const unsigned int target_level,
std::vector<BoundingBox<boost::geometry::dimension<Box>::value>> &boxes);
typename Allocators>
ExtractLevelVisitor<Value, Options, Translator, Box, Allocators>::
ExtractLevelVisitor(
- const Translator & translator,
+ const Translator &translator,
const unsigned int target_level,
std::vector<BoundingBox<boost::geometry::dimension<Box>::value>> &boxes)
: translator(translator)
typename Box,
typename Allocators>
NodeVisitor<Value, Options, Translator, Box, Allocators>::NodeVisitor(
- const Translator & translator,
+ const Translator &translator,
const unsigned int target_level,
std::vector<std::vector<BoundingBox<boost::geometry::dimension<Box>::value>>>
&bb_in_boxes)
template <int dim, int spacedim, typename VectorType>
void
coefficient_decay(FESeries::Legendre<dim, spacedim> &fe_legendre,
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & solution,
- Vector<float> & smoothness_indicators,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &solution,
+ Vector<float> &smoothness_indicators,
const VectorTools::NormType regression_strategy =
VectorTools::Linfty_norm,
const double smallest_abs_coefficient = 1e-10,
void
coefficient_decay_per_direction(
FESeries::Legendre<dim, spacedim> &fe_legendre,
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & solution,
- Vector<float> & smoothness_indicators,
- const ComponentMask & coefficients_predicate = {},
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &solution,
+ Vector<float> &smoothness_indicators,
+ const ComponentMask &coefficients_predicate = {},
const double smallest_abs_coefficient = 1e-10,
const bool only_flagged_cells = false);
template <int dim, int spacedim, typename VectorType>
void
coefficient_decay(FESeries::Fourier<dim, spacedim> &fe_fourier,
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & solution,
- Vector<float> & smoothness_indicators,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &solution,
+ Vector<float> &smoothness_indicators,
const VectorTools::NormType regression_strategy =
VectorTools::Linfty_norm,
const double smallest_abs_coefficient = 1e-10,
void
coefficient_decay_per_direction(
FESeries::Fourier<dim, spacedim> &fe_fourier,
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & solution,
- Vector<float> & smoothness_indicators,
- const ComponentMask & coefficients_predicate = {},
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &solution,
+ Vector<float> &smoothness_indicators,
+ const ComponentMask &coefficients_predicate = {},
const double smallest_abs_coefficient = 1e-10,
const bool only_flagged_cells = false);
*/
void
interpolate(const std::vector<VectorType> &all_in,
- std::vector<VectorType> & all_out) const;
+ std::vector<VectorType> &all_out) const;
/**
* Same as the previous function. It interpolates only one function. It
std::size_t
memory_consumption() const;
- std::vector<types::global_dof_index> * indices_ptr;
+ std::vector<types::global_dof_index> *indices_ptr;
std::vector<Vector<typename VectorType::value_type>> *dof_values_ptr;
unsigned int active_fe_index;
};
std::pair<std::array<FullMatrix<Number>, dim>,
std::array<FullMatrix<Number>, dim>>
create_laplace_tensor_product_matrix(
- const FiniteElement<1> & fe,
- const Quadrature<1> & quadrature,
+ const FiniteElement<1> &fe,
+ const Quadrature<1> &quadrature,
const dealii::ndarray<LaplaceBoundaryType, dim, 2> &boundary_ids,
- const dealii::ndarray<double, dim, 3> & cell_extent,
+ const dealii::ndarray<double, dim, 3> &cell_extent,
const unsigned int n_overlap = 1);
/**
std::array<FullMatrix<Number>, dim>>
create_laplace_tensor_product_matrix(
const typename Triangulation<dim>::cell_iterator &cell,
- const std::set<types::boundary_id> & dirichlet_boundaries,
- const std::set<types::boundary_id> & neumann_boundaries,
- const FiniteElement<1> & fe,
- const Quadrature<1> & quadrature,
- const dealii::ndarray<double, dim, 3> & cell_extent,
+ const std::set<types::boundary_id> &dirichlet_boundaries,
+ const std::set<types::boundary_id> &neumann_boundaries,
+ const FiniteElement<1> &fe,
+ const Quadrature<1> &quadrature,
+ const dealii::ndarray<double, dim, 3> &cell_extent,
const unsigned int n_overlap = 1);
} // namespace TensorProductMatrixCreator
std::tuple<FullMatrix<Number>, FullMatrix<Number>, bool>
create_reference_mass_and_stiffness_matrices(
const FiniteElement<1> &fe,
- const Quadrature<1> & quadrature)
+ const Quadrature<1> &quadrature)
{
Triangulation<1> tria;
GridGenerator::hyper_cube(tria);
std::pair<std::array<FullMatrix<Number>, dim>,
std::array<FullMatrix<Number>, dim>>
create_laplace_tensor_product_matrix(
- const FiniteElement<1> & fe,
- const Quadrature<1> & quadrature,
+ const FiniteElement<1> &fe,
+ const Quadrature<1> &quadrature,
const dealii::ndarray<LaplaceBoundaryType, dim, 2> &boundary_ids,
- const dealii::ndarray<double, dim, 3> & cell_extent,
+ const dealii::ndarray<double, dim, 3> &cell_extent,
const unsigned int n_overlap)
{
// 1) create element mass and siffness matrix (without overlap)
std::array<FullMatrix<Number>, dim>>
create_laplace_tensor_product_matrix(
const typename Triangulation<dim>::cell_iterator &cell,
- const std::set<types::boundary_id> & dirichlet_boundaries,
- const std::set<types::boundary_id> & neumann_boundaries,
- const FiniteElement<1> & fe,
- const Quadrature<1> & quadrature,
- const dealii::ndarray<double, dim, 3> & cell_extent,
+ const std::set<types::boundary_id> &dirichlet_boundaries,
+ const std::set<types::boundary_id> &neumann_boundaries,
+ const FiniteElement<1> &fe,
+ const Quadrature<1> &quadrature,
+ const dealii::ndarray<double, dim, 3> &cell_extent,
const unsigned int n_overlap)
{
dealii::ndarray<LaplaceBoundaryType, dim, 2> boundary_ids;
TimeStepBase_Tria(
const double time,
const Triangulation<dim, dim> &coarse_grid,
- const Flags & flags,
- const RefinementFlags & refinement_flags = RefinementFlags());
+ const Flags &flags,
+ const RefinementFlags &refinement_flags = RefinementFlags());
/**
* Destructor. At present, this does not more than releasing the lock on the
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
std::map<types::global_dof_index, number> &boundary_values,
- const ComponentMask & component_mask = {});
+ const ComponentMask &component_mask = {});
/**
* Like the previous function, but take a mapping collection to go with
void
interpolate_boundary_values(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
std::map<types::global_dof_index, number> &boundary_values,
- const ComponentMask & component_mask = {});
+ const ComponentMask &component_mask = {});
/**
* Like the previous functions but without Mapping argument, using
interpolate_boundary_values(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
std::map<types::global_dof_index, number> &boundary_values,
- const ComponentMask & component_mask = {});
+ const ComponentMask &component_mask = {});
/**
* Take only one boundary indicator with corresponding boundary function.
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_indicator,
- const Function<spacedim, number> & boundary_function,
+ const Function<spacedim, number> &boundary_function,
std::map<types::global_dof_index, number> &boundary_values,
- const ComponentMask & component_mask = {});
+ const ComponentMask &component_mask = {});
/**
* Like the previous function, but take a mapping collection to go with
void
interpolate_boundary_values(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_indicator,
- const Function<spacedim, number> & boundary_function,
- std::map<types::global_dof_index, number> & boundary_values,
- const ComponentMask & component_mask = {});
+ const Function<spacedim, number> &boundary_function,
+ std::map<types::global_dof_index, number> &boundary_values,
+ const ComponentMask &component_mask = {});
/**
* Like the previous functions but without Mapping argument, using
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_indicator,
- const Function<spacedim, number> & boundary_function,
+ const Function<spacedim, number> &boundary_function,
std::map<types::global_dof_index, number> &boundary_values,
- const ComponentMask & component_mask = {});
+ const ComponentMask &component_mask = {});
/**
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
AffineConstraints<number> &constraints,
- const ComponentMask & component_mask = {});
+ const ComponentMask &component_mask = {});
/**
* Like the previous function, but take a mapping collection to go with
void
interpolate_boundary_values(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
AffineConstraints<number> &constraints,
- const ComponentMask & component_mask = {});
+ const ComponentMask &component_mask = {});
/**
* Like the previous functions but without Mapping argument, using
interpolate_boundary_values(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
AffineConstraints<number> &constraints,
- const ComponentMask & component_mask = {});
+ const ComponentMask &component_mask = {});
/**
* Take only one boundary indicator with corresponding boundary function.
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_indicator,
const Function<spacedim, number> &boundary_function,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask = {});
+ AffineConstraints<number> &constraints,
+ const ComponentMask &component_mask = {});
/**
* Like the previous function, but take a mapping collection to go with
void
interpolate_boundary_values(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_indicator,
- const Function<spacedim, number> & boundary_function,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask = {});
+ const Function<spacedim, number> &boundary_function,
+ AffineConstraints<number> &constraints,
+ const ComponentMask &component_mask = {});
/**
* Like the previous functions but without Mapping argument, using
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_indicator,
const Function<spacedim, number> &boundary_function,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask = {});
+ AffineConstraints<number> &constraints,
+ const ComponentMask &component_mask = {});
/**
template <int dim, int spacedim, typename number>
void
project_boundary_values(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- const Quadrature<dim - 1> & q,
+ &boundary_functions,
+ const Quadrature<dim - 1> &q,
std::map<types::global_dof_index, number> &boundary_values,
std::vector<unsigned int> component_mapping = {});
project_boundary_values(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_function,
- const Quadrature<dim - 1> & q,
+ &boundary_function,
+ const Quadrature<dim - 1> &q,
std::map<types::global_dof_index, number> &boundary_values,
std::vector<unsigned int> component_mapping = {});
void
project_boundary_values(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- const hp::QCollection<dim - 1> & q,
+ &boundary_functions,
+ const hp::QCollection<dim - 1> &q,
std::map<types::global_dof_index, number> &boundary_values,
std::vector<unsigned int> component_mapping = {});
project_boundary_values(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_function,
- const hp::QCollection<dim - 1> & q,
+ &boundary_function,
+ const hp::QCollection<dim - 1> &q,
std::map<types::global_dof_index, number> &boundary_values,
std::vector<unsigned int> component_mapping = {});
template <int dim, int spacedim, typename number>
void
project_boundary_values(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
+ &boundary_functions,
const Quadrature<dim - 1> &q,
AffineConstraints<number> &constraints,
std::vector<unsigned int> component_mapping = {});
project_boundary_values(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_function,
+ &boundary_function,
const Quadrature<dim - 1> &q,
AffineConstraints<number> &constraints,
std::vector<unsigned int> component_mapping = {});
template <int dim, typename number>
void
project_boundary_values_curl_conforming_l2(
- const DoFHandler<dim, dim> & dof_handler,
+ const DoFHandler<dim, dim> &dof_handler,
const unsigned int first_vector_component,
const Function<dim, number> &boundary_function,
const types::boundary_id boundary_component,
- AffineConstraints<number> & constraints,
- const Mapping<dim> & mapping);
+ AffineConstraints<number> &constraints,
+ const Mapping<dim> &mapping);
/**
template <int dim, typename number>
void
project_boundary_values_curl_conforming_l2(
- const DoFHandler<dim, dim> & dof_handler,
+ const DoFHandler<dim, dim> &dof_handler,
const unsigned int first_vector_component,
- const Function<dim, number> & boundary_function,
+ const Function<dim, number> &boundary_function,
const types::boundary_id boundary_component,
- AffineConstraints<number> & constraints,
+ AffineConstraints<number> &constraints,
const hp::MappingCollection<dim, dim> &mapping_collection =
hp::StaticMappingQ1<dim>::mapping_collection);
template <int dim, typename number, typename number2 = number>
void
project_boundary_values_div_conforming(
- const DoFHandler<dim, dim> & dof_handler,
+ const DoFHandler<dim, dim> &dof_handler,
const unsigned int first_vector_component,
const Function<dim, number2> &boundary_function,
const types::boundary_id boundary_component,
- AffineConstraints<number> & constraints,
- const Mapping<dim> & mapping);
+ AffineConstraints<number> &constraints,
+ const Mapping<dim> &mapping);
/**
* Same as above for the hp-namespace.
template <int dim, typename number, typename number2 = number>
void
project_boundary_values_div_conforming(
- const DoFHandler<dim, dim> & dof_handler,
+ const DoFHandler<dim, dim> &dof_handler,
const unsigned int first_vector_component,
- const Function<dim, number2> & boundary_function,
+ const Function<dim, number2> &boundary_function,
const types::boundary_id boundary_component,
- AffineConstraints<number> & constraints,
+ AffineConstraints<number> &constraints,
const hp::MappingCollection<dim, dim> &mapping_collection =
hp::StaticMappingQ1<dim>::mapping_collection);
class M_or_MC>
static inline void
do_interpolate_boundary_values(
- const M_or_MC<dim, spacedim> & mapping,
+ const M_or_MC<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
std::map<types::global_dof_index, number> &boundary_values,
- const ComponentMask & component_mask)
+ const ComponentMask &component_mask)
{
Assert(
component_mask.represents_n_components(dof.get_fe(0).n_components()),
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
std::map<types::global_dof_index, number> &boundary_values,
- const ComponentMask & component_mask_)
+ const ComponentMask &component_mask_)
{
internal::do_interpolate_boundary_values(
mapping, dof, function_map, boundary_values, component_mask_);
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_component,
- const Function<spacedim, number> & boundary_function,
+ const Function<spacedim, number> &boundary_function,
std::map<types::global_dof_index, number> &boundary_values,
- const ComponentMask & component_mask)
+ const ComponentMask &component_mask)
{
std::map<types::boundary_id, const Function<spacedim, number> *>
function_map = {{boundary_component, &boundary_function}};
void
interpolate_boundary_values(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
std::map<types::global_dof_index, number> &boundary_values,
- const ComponentMask & component_mask_)
+ const ComponentMask &component_mask_)
{
internal::do_interpolate_boundary_values(
mapping, dof, function_map, boundary_values, component_mask_);
void
interpolate_boundary_values(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_component,
- const Function<spacedim, number> & boundary_function,
- std::map<types::global_dof_index, number> & boundary_values,
- const ComponentMask & component_mask)
+ const Function<spacedim, number> &boundary_function,
+ std::map<types::global_dof_index, number> &boundary_values,
+ const ComponentMask &component_mask)
{
std::map<types::boundary_id, const Function<spacedim, number> *>
function_map = {{boundary_component, &boundary_function}};
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_component,
- const Function<spacedim, number> & boundary_function,
+ const Function<spacedim, number> &boundary_function,
std::map<types::global_dof_index, number> &boundary_values,
- const ComponentMask & component_mask)
+ const ComponentMask &component_mask)
{
interpolate_boundary_values(get_default_linear_mapping(
dof.get_triangulation()),
interpolate_boundary_values(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
std::map<types::global_dof_index, number> &boundary_values,
- const ComponentMask & component_mask)
+ const ComponentMask &component_mask)
{
interpolate_boundary_values(get_default_linear_mapping(
dof.get_triangulation()),
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
AffineConstraints<number> &constraints,
- const ComponentMask & component_mask_)
+ const ComponentMask &component_mask_)
{
std::map<types::global_dof_index, number> boundary_values;
interpolate_boundary_values(
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_component,
const Function<spacedim, number> &boundary_function,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask)
+ AffineConstraints<number> &constraints,
+ const ComponentMask &component_mask)
{
std::map<types::boundary_id, const Function<spacedim, number> *>
function_map = {{boundary_component, &boundary_function}};
void
interpolate_boundary_values(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
AffineConstraints<number> &constraints,
- const ComponentMask & component_mask_)
+ const ComponentMask &component_mask_)
{
std::map<types::global_dof_index, number> boundary_values;
interpolate_boundary_values(
void
interpolate_boundary_values(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_component,
- const Function<spacedim, number> & boundary_function,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask)
+ const Function<spacedim, number> &boundary_function,
+ AffineConstraints<number> &constraints,
+ const ComponentMask &component_mask)
{
std::map<types::boundary_id, const Function<spacedim, number> *>
function_map = {{boundary_component, &boundary_function}};
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values(
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_component,
const Function<spacedim, number> &boundary_function,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask)
+ AffineConstraints<number> &constraints,
+ const ComponentMask &component_mask)
{
interpolate_boundary_values(get_default_linear_mapping(
dof.get_triangulation()),
interpolate_boundary_values(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & function_map,
+ &function_map,
AffineConstraints<number> &constraints,
- const ComponentMask & component_mask)
+ const ComponentMask &component_mask)
{
interpolate_boundary_values(get_default_linear_mapping(
dof.get_triangulation()),
typename number>
void
do_project_boundary_values(
- const M_or_MC<dim, spacedim> & mapping,
+ const M_or_MC<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- const Q_or_QC<dim - 1> & q,
+ &boundary_functions,
+ const Q_or_QC<dim - 1> &q,
std::map<types::global_dof_index, number> &boundary_values,
std::vector<unsigned int> component_mapping)
{
template <int dim, int spacedim, typename number>
void
project_boundary_values(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- const Quadrature<dim - 1> & q,
+ &boundary_functions,
+ const Quadrature<dim - 1> &q,
std::map<types::global_dof_index, number> &boundary_values,
std::vector<unsigned int> component_mapping)
{
project_boundary_values(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- const Quadrature<dim - 1> & q,
+ &boundary_functions,
+ const Quadrature<dim - 1> &q,
std::map<types::global_dof_index, number> &boundary_values,
std::vector<unsigned int> component_mapping)
{
void
project_boundary_values(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- const hp::QCollection<dim - 1> & q,
+ &boundary_functions,
+ const hp::QCollection<dim - 1> &q,
std::map<types::global_dof_index, number> &boundary_values,
std::vector<unsigned int> component_mapping)
{
project_boundary_values(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_function,
- const hp::QCollection<dim - 1> & q,
+ &boundary_function,
+ const hp::QCollection<dim - 1> &q,
std::map<types::global_dof_index, number> &boundary_values,
std::vector<unsigned int> component_mapping)
{
template <int dim, int spacedim, typename number>
void
project_boundary_values(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
+ &boundary_functions,
const Quadrature<dim - 1> &q,
AffineConstraints<number> &constraints,
std::vector<unsigned int> component_mapping)
project_boundary_values(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
+ &boundary_functions,
const Quadrature<dim - 1> &q,
AffineConstraints<number> &constraints,
std::vector<unsigned int> component_mapping)
{
template <int dim, typename cell_iterator, typename number>
std::enable_if_t<dim == 3>
- compute_edge_projection_l2(const cell_iterator & cell,
+ compute_edge_projection_l2(const cell_iterator &cell,
const unsigned int face,
const unsigned int line,
- hp::FEValues<dim> & hp_fe_values,
+ hp::FEValues<dim> &hp_fe_values,
const Function<dim, number> &boundary_function,
const unsigned int first_vector_component,
std::vector<number> &dof_values,
- std::vector<bool> & dofs_processed)
+ std::vector<bool> &dofs_processed)
{
// This function computes the L2-projection of the given
// boundary function on 3d edges and returns the constraints
template <int dim, typename cell_iterator, typename number>
void
compute_face_projection_curl_conforming_l2(
- const cell_iterator & cell,
+ const cell_iterator &cell,
const unsigned int face,
- hp::FEFaceValues<dim> & hp_fe_face_values,
+ hp::FEFaceValues<dim> &hp_fe_face_values,
const Function<dim, number> &boundary_function,
const unsigned int first_vector_component,
- std::vector<number> & dof_values,
- std::vector<bool> & dofs_processed)
+ std::vector<number> &dof_values,
+ std::vector<bool> &dofs_processed)
{
// This function computes the L2-projection of the boundary
// function on the interior of faces only. In 3d, this should only be
hp_fe_face_values.get_present_fe_values();
// Initialize the required objects.
- const FiniteElement<dim> & fe = cell->get_fe();
+ const FiniteElement<dim> &fe = cell->get_fe();
const std::vector<Point<dim>> &quadrature_points =
fe_face_values.get_quadrature_points();
template <int dim, int spacedim, typename number>
void
compute_project_boundary_values_curl_conforming_l2(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
- const Function<dim, number> & boundary_function,
+ const Function<dim, number> &boundary_function,
const types::boundary_id boundary_component,
- AffineConstraints<number> & constraints,
+ AffineConstraints<number> &constraints,
const hp::MappingCollection<dim, dim> &mapping_collection)
{
// L2-projection based interpolation formed in one (in 2d) or two (in 3d)
template <int dim, typename number>
void
project_boundary_values_curl_conforming_l2(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
const unsigned int first_vector_component,
const Function<dim, number> &boundary_function,
const types::boundary_id boundary_component,
- AffineConstraints<number> & constraints,
- const Mapping<dim> & mapping)
+ AffineConstraints<number> &constraints,
+ const Mapping<dim> &mapping)
{
// non-hp-version - calls the internal
// compute_project_boundary_values_curl_conforming_l2() function
template <int dim, typename number>
void
project_boundary_values_curl_conforming_l2(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
const unsigned int first_vector_component,
- const Function<dim, number> & boundary_function,
+ const Function<dim, number> &boundary_function,
const types::boundary_id boundary_component,
- AffineConstraints<number> & constraints,
+ AffineConstraints<number> &constraints,
const hp::MappingCollection<dim, dim> &mapping_collection)
{
// hp-version - calls the internal
template <typename cell_iterator, typename number, typename number2>
void
compute_face_projection_div_conforming(
- const cell_iterator & cell,
+ const cell_iterator &cell,
const unsigned int face,
- const FEFaceValues<2> & fe_values,
+ const FEFaceValues<2> &fe_values,
const unsigned int first_vector_component,
- const Function<2, number2> & boundary_function,
+ const Function<2, number2> &boundary_function,
const std::vector<DerivativeForm<1, 2, 2>> &jacobians,
- AffineConstraints<number> & constraints)
+ AffineConstraints<number> &constraints)
{
// Compute the integral over the product of the normal components of
// the boundary function times the normal components of the shape
// functions supported on the boundary.
const FEValuesExtractors::Vector vec(first_vector_component);
- const FiniteElement<2> & fe = cell->get_fe();
+ const FiniteElement<2> &fe = cell->get_fe();
const std::vector<Tensor<1, 2>> &normals = fe_values.get_normal_vectors();
const unsigned int
face_coordinate_direction[GeometryInfo<2>::faces_per_cell] = {1,
template <typename cell_iterator, typename number, typename number2>
void
compute_face_projection_div_conforming(
- const cell_iterator & cell,
+ const cell_iterator &cell,
const unsigned int face,
- const FEFaceValues<3> & fe_values,
+ const FEFaceValues<3> &fe_values,
const unsigned int first_vector_component,
- const Function<3, number2> & boundary_function,
+ const Function<3, number2> &boundary_function,
const std::vector<DerivativeForm<1, 3, 3>> &jacobians,
- std::vector<number> & dof_values,
- std::vector<types::global_dof_index> & projected_dofs)
+ std::vector<number> &dof_values,
+ std::vector<types::global_dof_index> &projected_dofs)
{
// Compute the intergral over the product of the normal components of
// the boundary function times the normal components of the shape
// functions supported on the boundary.
const FEValuesExtractors::Vector vec(first_vector_component);
- const FiniteElement<3> & fe = cell->get_fe();
+ const FiniteElement<3> &fe = cell->get_fe();
const std::vector<Tensor<1, 3>> &normals = fe_values.get_normal_vectors();
const unsigned int
face_coordinate_directions[GeometryInfo<3>::faces_per_cell][2] = {
template <int dim, typename number, typename number2>
void
project_boundary_values_div_conforming(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
const unsigned int first_vector_component,
const Function<dim, number2> &boundary_function,
const types::boundary_id boundary_component,
- AffineConstraints<number> & constraints,
- const Mapping<dim> & mapping)
+ AffineConstraints<number> &constraints,
+ const Mapping<dim> &mapping)
{
const unsigned int spacedim = dim;
// Interpolate the normal components
// normal components of the shape
// functions supported on the
// boundary.
- const FiniteElement<dim> & fe = dof_handler.get_fe();
+ const FiniteElement<dim> &fe = dof_handler.get_fe();
QGauss<dim - 1> face_quadrature(fe.degree + 1);
FEFaceValues<dim> fe_face_values(mapping,
fe,
template <int dim, typename number, typename number2>
void
project_boundary_values_div_conforming(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
const unsigned int first_vector_component,
- const Function<dim, number2> & boundary_function,
+ const Function<dim, number2> &boundary_function,
const types::boundary_id boundary_component,
- AffineConstraints<number> & constraints,
+ AffineConstraints<number> &constraints,
const hp::MappingCollection<dim, dim> &mapping_collection)
{
const unsigned int spacedim = dim;
* Convert a string to a NormType.
*/
static VectorTools::NormType
- to_value(const std::string & str,
+ to_value(const std::string &str,
const Patterns::PatternBase &p =
*Convert<VectorTools::NormType>::to_pattern())
{
template <int dim, int spacedim>
void
compute_nonzero_normal_flux_constraints(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
const std::map<types::boundary_id, const Function<spacedim, double> *>
- & function_map,
- AffineConstraints<double> & constraints,
+ &function_map,
+ AffineConstraints<double> &constraints,
const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
template <int dim, int spacedim>
void
compute_nonzero_normal_flux_constraints_on_level(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
const std::map<types::boundary_id, const Function<spacedim, double> *>
- & function_map,
- AffineConstraints<double> & constraints,
+ &function_map,
+ AffineConstraints<double> &constraints,
const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.ReferenceCell::get_default_linear_mapping<dim, spacedim>()
#endif
),
- const IndexSet & refinement_edge_indices = IndexSet(),
+ const IndexSet &refinement_edge_indices = IndexSet(),
const unsigned int level = numbers::invalid_unsigned_int);
/**
template <int dim, int spacedim>
void
compute_no_normal_flux_constraints(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
- AffineConstraints<double> & constraints,
- const Mapping<dim, spacedim> & mapping =
+ AffineConstraints<double> &constraints,
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()
template <int dim, int spacedim>
void
compute_no_normal_flux_constraints_on_level(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
- AffineConstraints<double> & constraints,
- const Mapping<dim, spacedim> & mapping =
+ AffineConstraints<double> &constraints,
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()
.ReferenceCell::get_default_linear_mapping<dim, spacedim>()
#endif
),
- const IndexSet & refinement_edge_indices = IndexSet(),
+ const IndexSet &refinement_edge_indices = IndexSet(),
const unsigned int level = numbers::invalid_unsigned_int);
/**
template <int dim, int spacedim>
void
compute_nonzero_tangential_flux_constraints(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
const std::map<types::boundary_id, const Function<spacedim, double> *>
- & function_map,
- AffineConstraints<double> & constraints,
+ &function_map,
+ AffineConstraints<double> &constraints,
const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
template <int dim, int spacedim>
void
compute_normal_flux_constraints(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
- AffineConstraints<double> & constraints,
- const Mapping<dim, spacedim> & mapping =
+ AffineConstraints<double> &constraints,
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()
template <int dim>
void
add_constraint(const VectorDoFTuple<dim> &dof_indices,
- const Tensor<1, dim> & constraining_vector,
+ const Tensor<1, dim> &constraining_vector,
AffineConstraints<double> &constraints,
const double inhomogeneity = 0)
{
void
add_tangentiality_constraints(
const VectorDoFTuple<dim> &dof_indices,
- const Tensor<1, dim> & tangent_vector,
+ const Tensor<1, dim> &tangent_vector,
AffineConstraints<double> &constraints,
- const Vector<double> & b_values = Vector<double>(dim))
+ const Vector<double> &b_values = Vector<double>(dim))
{
// choose the DoF that has the
// largest component in the
const typename DoFHandler<dim, spacedim>::cell_iterator &cell,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
- hp::FEFaceValues<dim, spacedim> & x_fe_face_values,
- const IndexSet & refinement_edge_indices,
+ hp::FEFaceValues<dim, spacedim> &x_fe_face_values,
+ const IndexSet &refinement_edge_indices,
const unsigned int level,
std::map<FaceDoFInfo, std::array<unsigned int, dim>> &dof_to_vector_dof)
{
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
const std::map<types::boundary_id, const Function<spacedim> *>
- & function_map,
+ &function_map,
hp::FEFaceValues<dim, spacedim> &x_fe_face_values,
const unsigned int n_dofs,
- const IndexSet & refinement_edge_indices,
+ const IndexSet &refinement_edge_indices,
const unsigned int level,
std::multimap<
VectorDoFTuple<dim>,
std::pair<Tensor<1, dim>,
typename DoFHandler<dim, spacedim>::cell_iterator>>
- & dof_to_normals_map,
+ &dof_to_normals_map,
std::map<VectorDoFTuple<dim>, Vector<double>> &dof_vector_to_b_values)
{
// mapping from (active_fe_index, face_no and local
template <int dim, int spacedim>
void
compute_nonzero_normal_flux_constraints_active_or_level(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
const std::map<types::boundary_id, const Function<spacedim> *>
- & function_map,
- AffineConstraints<double> & constraints,
+ &function_map,
+ AffineConstraints<double> &constraints,
const Mapping<dim, spacedim> &mapping,
- const IndexSet & refinement_edge_indices = IndexSet(),
+ const IndexSet &refinement_edge_indices = IndexSet(),
const unsigned int level = numbers::invalid_unsigned_int)
{
Assert(dim > 1,
template <int dim, int spacedim>
void
compute_nonzero_normal_flux_constraints(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
const std::map<types::boundary_id, const Function<spacedim> *>
- & function_map,
- AffineConstraints<double> & constraints,
+ &function_map,
+ AffineConstraints<double> &constraints,
const Mapping<dim, spacedim> &mapping)
{
internal::compute_nonzero_normal_flux_constraints_active_or_level(
template <int dim, int spacedim>
void
compute_nonzero_normal_flux_constraints_on_level(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
const std::map<types::boundary_id, const Function<spacedim> *>
- & function_map,
- AffineConstraints<double> & constraints,
+ &function_map,
+ AffineConstraints<double> &constraints,
const Mapping<dim, spacedim> &mapping,
- const IndexSet & refinement_edge_indices,
+ const IndexSet &refinement_edge_indices,
const unsigned int level)
{
internal::compute_nonzero_normal_flux_constraints_active_or_level(
template <int dim, int spacedim>
void
compute_nonzero_tangential_flux_constraints(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
const std::map<types::boundary_id, const Function<spacedim> *>
- & function_map,
- AffineConstraints<double> & constraints,
+ &function_map,
+ AffineConstraints<double> &constraints,
const Mapping<dim, spacedim> &mapping)
{
AffineConstraints<double> no_normal_flux_constraints(
template <int dim, int spacedim>
void
compute_no_normal_flux_constraints(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
- AffineConstraints<double> & constraints,
- const Mapping<dim, spacedim> & mapping)
+ AffineConstraints<double> &constraints,
+ const Mapping<dim, spacedim> &mapping)
{
Functions::ZeroFunction<dim> zero_function(dim);
std::map<types::boundary_id, const Function<spacedim> *> function_map;
template <int dim, int spacedim>
void
compute_no_normal_flux_constraints_on_level(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
- AffineConstraints<double> & constraints,
- const Mapping<dim, spacedim> & mapping,
- const IndexSet & refinement_edge_indices,
+ AffineConstraints<double> &constraints,
+ const Mapping<dim, spacedim> &mapping,
+ const IndexSet &refinement_edge_indices,
const unsigned int level)
{
Functions::ZeroFunction<dim> zero_function(dim);
template <int dim, int spacedim>
void
compute_normal_flux_constraints(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
- AffineConstraints<double> & constraints,
- const Mapping<dim, spacedim> & mapping)
+ AffineConstraints<double> &constraints,
+ const Mapping<dim, spacedim> &mapping)
{
Functions::ZeroFunction<dim> zero_function(dim);
std::map<types::boundary_id, const Function<spacedim> *> function_map;
dim,
spacedim,
typename VectorType::value_type>::
- value_type> point_values(const Mapping<dim> & mapping,
+ value_type> point_values(const Mapping<dim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const VectorType & vector,
+ const VectorType &vector,
const std::vector<Point<spacedim>>
&evaluation_points,
Utilities::MPI::RemotePointEvaluation<dim,
spacedim>
- & cache,
+ &cache,
const EvaluationFlags::EvaluationFlags flags =
EvaluationFlags::avg,
const unsigned int first_selected_component = 0);
typename VectorType::value_type>::
value_type> point_values(const Utilities::MPI::
RemotePointEvaluation<dim, spacedim> &cache,
- const MeshType<dim, spacedim> & mesh,
- const VectorType & vector,
+ const MeshType<dim, spacedim> &mesh,
+ const VectorType &vector,
const EvaluationFlags::EvaluationFlags flags =
EvaluationFlags::avg,
const unsigned int first_selected_component = 0);
dim,
spacedim,
typename VectorType::value_type>::
- gradient_type> point_gradients(const Mapping<dim> & mapping,
+ gradient_type> point_gradients(const Mapping<dim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const VectorType & vector,
+ const VectorType &vector,
const std::vector<Point<spacedim>>
&evaluation_points,
Utilities::MPI::RemotePointEvaluation<
typename VectorType::value_type>::
gradient_type> point_gradients(const Utilities::MPI::
RemotePointEvaluation<dim, spacedim>
- & cache,
+ &cache,
const MeshType<dim, spacedim> &mesh,
- const VectorType & vector,
+ const VectorType &vector,
const EvaluationFlags::EvaluationFlags
flags = EvaluationFlags::avg,
const unsigned int
dim,
spacedim,
typename VectorType::value_type>::
- value_type> point_values(const Mapping<dim> & mapping,
+ value_type> point_values(const Mapping<dim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const VectorType & vector,
+ const VectorType &vector,
const std::vector<Point<spacedim>>
&evaluation_points,
Utilities::MPI::RemotePointEvaluation<dim,
spacedim>
- & cache,
+ &cache,
const EvaluationFlags::EvaluationFlags flags,
const unsigned int first_selected_component)
{
dim,
spacedim,
typename VectorType::value_type>::
- gradient_type> point_gradients(const Mapping<dim> & mapping,
+ gradient_type> point_gradients(const Mapping<dim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const VectorType & vector,
+ const VectorType &vector,
const std::vector<Point<spacedim>>
&evaluation_points,
Utilities::MPI::RemotePointEvaluation<
template <typename T>
T
reduce(const EvaluationFlags::EvaluationFlags &flags,
- const ArrayView<const T> & values)
+ const ArrayView<const T> &values)
{
switch (flags)
{
*/
template <int rank, int dim, typename Number>
Tensor<rank, dim, Number>
- reduce(const EvaluationFlags::EvaluationFlags & flags,
+ reduce(const EvaluationFlags::EvaluationFlags &flags,
const ArrayView<const Tensor<rank, dim, Number>> &values)
{
switch (flags)
const unsigned int i,
const typename Utilities::MPI::RemotePointEvaluation<dim,
spacedim>::CellData
- & cell_data,
+ &cell_data,
const Utilities::MPI::RemotePointEvaluation<dim, spacedim> &cache,
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & vector,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &vector,
const UpdateFlags update_flags,
const dealii::EvaluationFlags::EvaluationFlags evaluation_flags,
const unsigned int first_selected_component,
spacedim,
typename VectorType::value_type> &,
const unsigned int &)> process_quadrature_point,
- const ArrayView<value_type> & values,
+ const ArrayView<value_type> &values,
std::vector<typename VectorType::value_type> &solution_values,
std::vector<
std::unique_ptr<FEPointEvaluation<n_components,
template <int dim, int spacedim, typename Number>
Number
get_value(
- const Triangulation<dim, spacedim> & tria,
- const Vector<Number> & vector,
+ const Triangulation<dim, spacedim> &tria,
+ const Vector<Number> &vector,
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell)
{
(void)tria;
template <int dim, int spacedim, typename Number>
Number
get_value(
- const Triangulation<dim, spacedim> & tria,
- const LinearAlgebra::distributed::Vector<Number> & vector,
+ const Triangulation<dim, spacedim> &tria,
+ const LinearAlgebra::distributed::Vector<Number> &vector,
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell)
{
const auto distributed_tria =
&cell_data,
const Utilities::MPI::RemotePointEvaluation<dim, spacedim> &,
const Triangulation<dim, spacedim> &triangulation,
- const VectorType & vector,
+ const VectorType &vector,
const UpdateFlags,
const dealii::EvaluationFlags::EvaluationFlags evaluation_flags,
const unsigned int first_selected_component,
&&concepts::is_triangulation_or_dof_handler<MeshType>)
inline std::vector<value_type> evaluate_at_points(
const Utilities::MPI::RemotePointEvaluation<dim, spacedim> &cache,
- const MeshType & mesh,
- const VectorType & vector,
+ const MeshType &mesh,
+ const VectorType &vector,
const EvaluationFlags::EvaluationFlags flags,
const unsigned int first_selected_component,
const UpdateFlags update_flags,
const auto evaluation_point_results = [&]() {
// helper function for accessing the global vector and interpolating
// the results onto the points
- const auto evaluation_function = [&](auto & values,
+ const auto evaluation_function = [&](auto &values,
const auto &cell_data) {
std::vector<typename VectorType::value_type> solution_values;
typename VectorType::value_type>::
value_type> point_values(const Utilities::MPI::
RemotePointEvaluation<dim, spacedim> &cache,
- const MeshType<dim, spacedim> & mesh,
- const VectorType & vector,
+ const MeshType<dim, spacedim> &mesh,
+ const VectorType &vector,
const EvaluationFlags::EvaluationFlags flags,
const unsigned int first_selected_component)
{
typename VectorType::value_type>::
gradient_type> point_gradients(const Utilities::MPI::
RemotePointEvaluation<dim, spacedim>
- & cache,
+ &cache,
const MeshType<dim, spacedim> &mesh,
- const VectorType & vector,
+ const VectorType &vector,
const EvaluationFlags::EvaluationFlags
flags,
const unsigned int
*/
template <int dim, typename Number, class OutVector, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<OutVector>)
- void integrate_difference(const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const ReadVector<Number> & fe_function,
+ void integrate_difference(const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const ReadVector<Number> &fe_function,
const Function<spacedim, Number> &exact_solution,
- OutVector & difference,
- const Quadrature<dim> & q,
- const NormType & norm,
+ OutVector &difference,
+ const Quadrature<dim> &q,
+ const NormType &norm,
const Function<spacedim, double> *weight = nullptr,
const double exponent = 2.);
*/
template <int dim, typename Number, class OutVector, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<OutVector>)
- void integrate_difference(const DoFHandler<dim, spacedim> & dof,
- const ReadVector<Number> & fe_function,
+ void integrate_difference(const DoFHandler<dim, spacedim> &dof,
+ const ReadVector<Number> &fe_function,
const Function<spacedim, Number> &exact_solution,
- OutVector & difference,
- const Quadrature<dim> & q,
- const NormType & norm,
+ OutVector &difference,
+ const Quadrature<dim> &q,
+ const NormType &norm,
const Function<spacedim, double> *weight = nullptr,
const double exponent = 2.);
template <int dim, typename Number, class OutVector, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<OutVector>)
void integrate_difference(const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const ReadVector<Number> & fe_function,
+ const DoFHandler<dim, spacedim> &dof,
+ const ReadVector<Number> &fe_function,
const Function<spacedim, Number> &exact_solution,
- OutVector & difference,
- const hp::QCollection<dim> & q,
- const NormType & norm,
+ OutVector &difference,
+ const hp::QCollection<dim> &q,
+ const NormType &norm,
const Function<spacedim, double> *weight = nullptr,
const double exponent = 2.);
*/
template <int dim, typename Number, class OutVector, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<OutVector>)
- void integrate_difference(const DoFHandler<dim, spacedim> & dof,
- const ReadVector<Number> & fe_function,
+ void integrate_difference(const DoFHandler<dim, spacedim> &dof,
+ const ReadVector<Number> &fe_function,
const Function<spacedim, Number> &exact_solution,
- OutVector & difference,
- const hp::QCollection<dim> & q,
- const NormType & norm,
+ OutVector &difference,
+ const hp::QCollection<dim> &q,
+ const NormType &norm,
const Function<spacedim, double> *weight = nullptr,
const double exponent = 2.);
struct IDScratchData
{
IDScratchData(const dealii::hp::MappingCollection<dim, spacedim> &mapping,
- const dealii::hp::FECollection<dim, spacedim> & fe,
- const dealii::hp::QCollection<dim> & q,
+ const dealii::hp::FECollection<dim, spacedim> &fe,
+ const dealii::hp::QCollection<dim> &q,
const UpdateFlags update_flags);
IDScratchData(const IDScratchData &data);
template <int dim, int spacedim, typename Number>
IDScratchData<dim, spacedim, Number>::IDScratchData(
const dealii::hp::MappingCollection<dim, spacedim> &mapping,
- const dealii::hp::FECollection<dim, spacedim> & fe,
- const dealii::hp::QCollection<dim> & q,
+ const dealii::hp::FECollection<dim, spacedim> &fe,
+ const dealii::hp::QCollection<dim> &q,
const UpdateFlags update_flags)
: x_fe_values(mapping, fe, q, update_flags)
{}
template <int dim, int spacedim, typename Number>
double
integrate_difference_inner(const Function<spacedim, Number> &exact_solution,
- const NormType & norm,
- const Function<spacedim> * weight,
+ const NormType &norm,
+ const Function<spacedim> *weight,
const UpdateFlags update_flags,
const double exponent,
const unsigned int n_components,
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<OutVector>)
static void do_integrate_difference(
const dealii::hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const ReadVector<Number> & fe_function,
- const Function<spacedim, Number> & exact_solution,
- OutVector & difference,
- const dealii::hp::QCollection<dim> & q,
- const NormType & norm,
- const Function<spacedim> * weight,
+ const DoFHandler<dim, spacedim> &dof,
+ const ReadVector<Number> &fe_function,
+ const Function<spacedim, Number> &exact_solution,
+ OutVector &difference,
+ const dealii::hp::QCollection<dim> &q,
+ const NormType &norm,
+ const Function<spacedim> *weight,
const double exponent_1)
{
// we mark the "exponent" parameter to this function "const" since it is
template <int dim, typename Number, class OutVector, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<OutVector>)
- void integrate_difference(const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const ReadVector<Number> & fe_function,
+ void integrate_difference(const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const ReadVector<Number> &fe_function,
const Function<spacedim, Number> &exact_solution,
- OutVector & difference,
- const Quadrature<dim> & q,
- const NormType & norm,
- const Function<spacedim> * weight,
+ OutVector &difference,
+ const Quadrature<dim> &q,
+ const NormType &norm,
+ const Function<spacedim> *weight,
const double exponent)
{
internal::do_integrate_difference(hp::MappingCollection<dim, spacedim>(
template <int dim, typename Number, class OutVector, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<OutVector>)
- void integrate_difference(const DoFHandler<dim, spacedim> & dof,
- const ReadVector<Number> & fe_function,
+ void integrate_difference(const DoFHandler<dim, spacedim> &dof,
+ const ReadVector<Number> &fe_function,
const Function<spacedim, Number> &exact_solution,
- OutVector & difference,
- const Quadrature<dim> & q,
- const NormType & norm,
- const Function<spacedim> * weight,
+ OutVector &difference,
+ const Quadrature<dim> &q,
+ const NormType &norm,
+ const Function<spacedim> *weight,
const double exponent)
{
internal::do_integrate_difference(
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<OutVector>)
void integrate_difference(
const dealii::hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const ReadVector<Number> & fe_function,
- const Function<spacedim, Number> & exact_solution,
- OutVector & difference,
- const dealii::hp::QCollection<dim> & q,
- const NormType & norm,
- const Function<spacedim> * weight,
+ const DoFHandler<dim, spacedim> &dof,
+ const ReadVector<Number> &fe_function,
+ const Function<spacedim, Number> &exact_solution,
+ OutVector &difference,
+ const dealii::hp::QCollection<dim> &q,
+ const NormType &norm,
+ const Function<spacedim> *weight,
const double exponent)
{
internal::do_integrate_difference(mapping,
template <int dim, typename Number, class OutVector, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<OutVector>)
- void integrate_difference(const DoFHandler<dim, spacedim> & dof,
- const ReadVector<Number> & fe_function,
- const Function<spacedim, Number> & exact_solution,
- OutVector & difference,
+ void integrate_difference(const DoFHandler<dim, spacedim> &dof,
+ const ReadVector<Number> &fe_function,
+ const Function<spacedim, Number> &exact_solution,
+ OutVector &difference,
const dealii::hp::QCollection<dim> &q,
- const NormType & norm,
- const Function<spacedim> * weight,
+ const NormType &norm,
+ const Function<spacedim> *weight,
const double exponent)
{
internal::do_integrate_difference(
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
+ VectorType &vec,
const ComponentMask &component_mask = {});
/**
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
+ VectorType &vec,
const ComponentMask &component_mask = {});
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate(
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
+ VectorType &vec,
const ComponentMask &component_mask = {});
/**
concepts::is_writable_dealii_vector_type<OutVector>)
void interpolate(const DoFHandler<dim, spacedim> &dof_1,
const DoFHandler<dim, spacedim> &dof_2,
- const FullMatrix<double> & transfer,
- const InVector & data_1,
- OutVector & data_2);
+ const FullMatrix<double> &transfer,
+ const InVector &data_1,
+ OutVector &data_2);
/**
* This function is a kind of generalization or modification of the very
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate_based_on_material_id(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
const std::map<types::material_id,
const Function<spacedim, typename VectorType::value_type> *>
- & function_map,
- VectorType & dst,
+ &function_map,
+ VectorType &dst,
const ComponentMask &component_mask = {});
/**
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate_to_different_mesh(const DoFHandler<dim, spacedim> &dof1,
- const VectorType & u1,
+ const VectorType &u1,
const DoFHandler<dim, spacedim> &dof2,
- VectorType & u2);
+ VectorType &u2);
/**
* Compute the interpolation of a @p dof1-function @p u1 to a @p dof2-function
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate_to_different_mesh(
- const DoFHandler<dim, spacedim> & dof1,
- const VectorType & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const DoFHandler<dim, spacedim> &dof1,
+ const VectorType &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename VectorType::value_type> &constraints,
- VectorType & u2);
+ VectorType &u2);
/**
* The same function as above, but takes an InterGridMap object directly as
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate_to_different_mesh(
- const InterGridMap<DoFHandler<dim, spacedim>> & intergridmap,
- const VectorType & u1,
+ const InterGridMap<DoFHandler<dim, spacedim>> &intergridmap,
+ const VectorType &u1,
const AffineConstraints<typename VectorType::value_type> &constraints,
- VectorType & u2);
+ VectorType &u2);
/** @} */
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void get_position_vector(const DoFHandler<dim, spacedim> &dh,
- VectorType & vector,
- const ComponentMask & mask = {});
+ VectorType &vector,
+ const ComponentMask &mask = {});
/**
* Like the above function but also taking @p mapping as argument.
*/
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
- void get_position_vector(const Mapping<dim, spacedim> & mapping,
+ void get_position_vector(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dh,
- VectorType & vector,
- const ComponentMask & mask = {});
+ VectorType &vector,
+ const ComponentMask &mask = {});
/** @} */
} // namespace VectorTools
transform(const typename FiniteElementData<dim>::Conformity conformity,
const unsigned int offset,
const FEValuesType &fe_values_jacobians,
- T3 & function_values)
+ T3 &function_values)
{
switch (conformity)
{
unsigned int
apply_transform(const FiniteElement<dim, spacedim> &fe,
const unsigned int offset,
- const FEValuesType & fe_values_jacobians,
- T3 & function_values)
+ const FEValuesType &fe_values_jacobians,
+ T3 &function_values)
{
if (const auto *system =
dynamic_cast<const FESystem<dim, spacedim> *>(&fe))
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate(
const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const DoFHandler<dim, spacedim> & dof_handler,
- T & function,
- VectorType & vec,
- const ComponentMask & component_mask)
+ const DoFHandler<dim, spacedim> &dof_handler,
+ T &function,
+ VectorType &vec,
+ const ComponentMask &component_mask)
{
Assert(component_mask.represents_n_components(
dof_handler.get_fe_collection().n_components()),
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
- const ComponentMask & component_mask)
+ VectorType &vec,
+ const ComponentMask &component_mask)
{
AssertDimension(dof_handler.get_fe_collection().n_components(),
function.n_components);
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
- const ComponentMask & component_mask)
+ VectorType &vec,
+ const ComponentMask &component_mask)
{
interpolate(hp::MappingCollection<dim, spacedim>(mapping),
dof_handler,
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate(
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
- const ComponentMask & component_mask)
+ VectorType &vec,
+ const ComponentMask &component_mask)
{
AssertDimension(dof.get_fe_collection().n_components(),
function.n_components);
concepts::is_writable_dealii_vector_type<OutVector>)
void interpolate(const DoFHandler<dim, spacedim> &dof_1,
const DoFHandler<dim, spacedim> &dof_2,
- const FullMatrix<double> & transfer,
- const InVector & data_1,
- OutVector & data_2)
+ const FullMatrix<double> &transfer,
+ const InVector &data_1,
+ OutVector &data_2)
{
using number = typename OutVector::value_type;
Vector<number> cell_data_1(dof_1.get_fe().n_dofs_per_cell());
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void get_position_vector(const DoFHandler<dim, spacedim> &dh,
- VectorType & vector,
- const ComponentMask & mask)
+ VectorType &vector,
+ const ComponentMask &mask)
{
const FiniteElement<dim, spacedim> &fe = dh.get_fe();
get_position_vector(
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
- void get_position_vector(const Mapping<dim, spacedim> & map_q,
+ void get_position_vector(const Mapping<dim, spacedim> &map_q,
const DoFHandler<dim, spacedim> &dh,
- VectorType & vector,
- const ComponentMask & mask)
+ VectorType &vector,
+ const ComponentMask &mask)
{
AssertDimension(vector.size(), dh.n_dofs());
const FiniteElement<dim, spacedim> &fe = dh.get_fe();
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate_based_on_material_id(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
const std::map<types::material_id,
const Function<spacedim, typename VectorType::value_type> *>
- & functions,
- VectorType & vec,
+ &functions,
+ VectorType &vec,
const ComponentMask &component_mask)
{
// Create a small lambda capture wrapping the function map and call the
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate_to_different_mesh(const DoFHandler<dim, spacedim> &dof1,
- const VectorType & u1,
+ const VectorType &u1,
const DoFHandler<dim, spacedim> &dof2,
- VectorType & u2)
+ VectorType &u2)
{
Assert(GridTools::have_same_coarse_mesh(dof1, dof2),
ExcMessage("The two DoF handlers must represent triangulations that "
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate_to_different_mesh(
- const DoFHandler<dim, spacedim> & dof1,
- const VectorType & u1,
- const DoFHandler<dim, spacedim> & dof2,
+ const DoFHandler<dim, spacedim> &dof1,
+ const VectorType &u1,
+ const DoFHandler<dim, spacedim> &dof2,
const AffineConstraints<typename VectorType::value_type> &constraints,
- VectorType & u2)
+ VectorType &u2)
{
Assert(GridTools::have_same_coarse_mesh(dof1, dof2),
ExcMessage("The two DoF handlers must represent triangulations that "
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void interpolate_to_different_mesh(
- const InterGridMap<DoFHandler<dim, spacedim>> & intergridmap,
- const VectorType & u1,
+ const InterGridMap<DoFHandler<dim, spacedim>> &intergridmap,
+ const VectorType &u1,
const AffineConstraints<typename VectorType::value_type> &constraints,
- VectorType & u2)
+ VectorType &u2)
{
const DoFHandler<dim, spacedim> &dof1 = intergridmap.get_source_grid();
const DoFHandler<dim, spacedim> &dof2 = intergridmap.get_destination_grid();
*/
template <typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
- void subtract_mean_value(VectorType & v,
+ void subtract_mean_value(VectorType &v,
const std::vector<bool> &p_select = {});
/**
*/
template <typename VectorType, int dim, int spacedim = dim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
- void add_constant(VectorType & solution,
- const DoFHandler<dim, spacedim> & dof_handler,
+ void add_constant(VectorType &solution,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int component,
const typename VectorType::value_type constant_adjustment);
Number
compute_mean_value(
const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q_collection,
- const ReadVector<Number> & v,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q_collection,
+ const ReadVector<Number> &v,
const unsigned int component);
/**
*/
template <int dim, typename Number, int spacedim>
Number
- compute_mean_value(const Mapping<dim, spacedim> & mapping,
+ compute_mean_value(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & quadrature,
- const ReadVector<Number> & v,
+ const Quadrature<dim> &quadrature,
+ const ReadVector<Number> &v,
const unsigned int component);
/**
template <int dim, typename Number, int spacedim>
Number
compute_mean_value(const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & quadrature,
- const ReadVector<Number> & v,
+ const Quadrature<dim> &quadrature,
+ const ReadVector<Number> &v,
const unsigned int component);
/** @} */
} // namespace VectorTools
template <typename VectorType, int dim, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
- void add_constant(VectorType & solution,
- const DoFHandler<dim, spacedim> & dof_handler,
+ void add_constant(VectorType &solution,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int component,
const typename VectorType::value_type constant_adjustment)
{
Number
compute_mean_value(
const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q_collection,
- const ReadVector<Number> & v,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q_collection,
+ const ReadVector<Number> &v,
const unsigned int component)
{
const hp::FECollection<dim, spacedim> &fe_collection =
template <int dim, typename Number, int spacedim>
Number
- compute_mean_value(const Mapping<dim, spacedim> & mapping,
+ compute_mean_value(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & quadrature,
- const ReadVector<Number> & v,
+ const Quadrature<dim> &quadrature,
+ const ReadVector<Number> &v,
const unsigned int component)
{
return compute_mean_value(hp::MappingCollection<dim, spacedim>(mapping),
template <int dim, typename Number, int spacedim>
Number
compute_mean_value(const DoFHandler<dim, spacedim> &dof,
- const Quadrature<dim> & quadrature,
- const ReadVector<Number> & v,
+ const Quadrature<dim> &quadrature,
+ const ReadVector<Number> &v,
const unsigned int component)
{
return compute_mean_value(get_default_linear_mapping(
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_gradient(
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point,
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point,
std::vector<Tensor<1, spacedim, typename VectorType::value_type>> &value);
/**
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_gradient(
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point,
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point,
std::vector<Tensor<1, spacedim, typename VectorType::value_type>> &value);
/**
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
Tensor<1, spacedim, typename VectorType::value_type> point_gradient(
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point);
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point);
/**
* Same as above for hp.
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
Tensor<1, spacedim, typename VectorType::value_type> point_gradient(
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point);
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point);
/**
* Evaluate a possibly vector-valued finite element function defined by the
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_gradient(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point,
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point,
std::vector<Tensor<1, spacedim, typename VectorType::value_type>> &value);
/**
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_gradient(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point,
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point,
std::vector<Tensor<1, spacedim, typename VectorType::value_type>> &value);
/**
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
Tensor<1, spacedim, typename VectorType::value_type> point_gradient(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point);
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point);
/**
* Same as above for hp.
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
Tensor<1, spacedim, typename VectorType::value_type> point_gradient(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point);
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point);
/** @} */
} // namespace VectorTools
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_gradient(
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim> & point,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
std::vector<Tensor<1, spacedim, typename VectorType::value_type>>
&gradients)
{
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
Tensor<1, spacedim, typename VectorType::value_type> point_gradient(
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim> & point)
+ const VectorType &fe_function,
+ const Point<spacedim> &point)
{
if (dof.has_hp_capabilities() == false)
return point_gradient(get_default_linear_mapping(dof.get_triangulation()),
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_gradient(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim> & point,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
std::vector<Tensor<1, spacedim, typename VectorType::value_type>> &gradient)
{
const FiniteElement<dim> &fe = dof.get_fe();
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_gradient(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim> & point,
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
std::vector<Tensor<1, spacedim, typename VectorType::value_type>> &gradient)
{
using Number = typename VectorType::value_type;
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
Tensor<1, spacedim, typename VectorType::value_type> point_gradient(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim> & point)
+ const VectorType &fe_function,
+ const Point<spacedim> &point)
{
Assert(dof.get_fe(0).n_components() == 1,
ExcMessage(
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
Tensor<1, spacedim, typename VectorType::value_type> point_gradient(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim> & point)
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point)
{
Assert(dof.get_fe(0).n_components() == 1,
ExcMessage(
*/
template <int dim, int spacedim>
void
- create_point_source_vector(const Mapping<dim, spacedim> & mapping,
+ create_point_source_vector(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const Point<spacedim, double> & p,
- Vector<double> & rhs_vector);
+ const Point<spacedim, double> &p,
+ Vector<double> &rhs_vector);
/**
* Like the previous function, but for hp-objects.
void
create_point_source_vector(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const Point<spacedim, double> & p,
- Vector<double> & rhs_vector);
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const Point<spacedim, double> &p,
+ Vector<double> &rhs_vector);
/**
* Call the create_point_source_vector() function, see above, with
template <int dim, int spacedim>
void
create_point_source_vector(const DoFHandler<dim, spacedim> &dof_handler,
- const Point<spacedim, double> & p,
- Vector<double> & rhs_vector);
+ const Point<spacedim, double> &p,
+ Vector<double> &rhs_vector);
/**
* Create a right hand side vector for a point source at point @p p. This
*/
template <int dim, int spacedim>
void
- create_point_source_vector(const Mapping<dim, spacedim> & mapping,
+ create_point_source_vector(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const Point<spacedim, double> & p,
- const Point<dim, double> & direction,
- Vector<double> & rhs_vector);
+ const Point<spacedim, double> &p,
+ const Point<dim, double> &direction,
+ Vector<double> &rhs_vector);
/**
* Like the previous function, but for hp-objects.
void
create_point_source_vector(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const Point<spacedim, double> & p,
- const Point<dim, double> & direction,
- Vector<double> & rhs_vector);
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const Point<spacedim, double> &p,
+ const Point<dim, double> &direction,
+ Vector<double> &rhs_vector);
/**
* Call the create_point_source_vector() function for vector-valued finite
template <int dim, int spacedim>
void
create_point_source_vector(const DoFHandler<dim, spacedim> &dof_handler,
- const Point<spacedim, double> & p,
- const Point<dim, double> & direction,
- Vector<double> & rhs_vector);
+ const Point<spacedim, double> &p,
+ const Point<dim, double> &direction,
+ Vector<double> &rhs_vector);
/** @} */
/**
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_difference(
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
const Function<spacedim, typename VectorType::value_type> &exact_solution,
- Vector<typename VectorType::value_type> & difference,
- const Point<spacedim, double> & point);
+ Vector<typename VectorType::value_type> &difference,
+ const Point<spacedim, double> &point);
/**
* Point error evaluation. Find the first cell containing the given point
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_difference(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
const Function<spacedim, typename VectorType::value_type> &exact_solution,
- Vector<typename VectorType::value_type> & difference,
- const Point<spacedim, double> & point);
+ Vector<typename VectorType::value_type> &difference,
+ const Point<spacedim, double> &point);
/**
* Evaluate a possibly vector-valued finite element function defined by the
*/
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
- void point_value(const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point,
+ void point_value(const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point,
Vector<typename VectorType::value_type> &value);
/**
*/
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
- void point_value(const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point,
+ void point_value(const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point,
Vector<typename VectorType::value_type> &value);
/**
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
typename VectorType::value_type
point_value(const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point);
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point);
/**
* Same as above for hp.
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
typename VectorType::value_type
point_value(const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point);
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point);
/**
* Evaluate a possibly vector-valued finite element function defined by the
*/
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
- void point_value(const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point,
+ void point_value(const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point,
Vector<typename VectorType::value_type> &value);
/**
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_value(const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point,
- Vector<typename VectorType::value_type> & value);
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point,
+ Vector<typename VectorType::value_type> &value);
/**
* Evaluate a scalar finite element function defined by the given DoFHandler
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
typename VectorType::value_type
- point_value(const Mapping<dim, spacedim> & mapping,
+ point_value(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point);
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point);
/**
* Same as above for hp.
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
typename VectorType::value_type
point_value(const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim, double> & point);
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim, double> &point);
/** @} */
} // namespace VectorTools
{
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
- void point_value(const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim> & point,
+ void point_value(const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
Vector<typename VectorType::value_type> &value)
{
if (dof.has_hp_capabilities() == false)
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
typename VectorType::value_type
point_value(const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim> & point)
+ const VectorType &fe_function,
+ const Point<spacedim> &point)
{
if (dof.has_hp_capabilities() == false)
return point_value(get_default_linear_mapping(dof.get_triangulation()),
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
- void point_value(const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim> & point,
+ void point_value(const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
Vector<typename VectorType::value_type> &value)
{
using Number = typename VectorType::value_type;
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_value(const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim> & point,
- Vector<typename VectorType::value_type> & value)
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
+ Vector<typename VectorType::value_type> &value)
{
using Number = typename VectorType::value_type;
const hp::FECollection<dim, spacedim> &fe = dof.get_fe_collection();
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
typename VectorType::value_type
- point_value(const Mapping<dim, spacedim> & mapping,
+ point_value(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const VectorType & fe_function,
- const Point<spacedim> & point)
+ const VectorType &fe_function,
+ const Point<spacedim> &point)
{
Assert(dof.get_fe(0).n_components() == 1,
ExcMessage(
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
typename VectorType::value_type
point_value(const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
- const Point<spacedim> & point)
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point)
{
Assert(dof.get_fe(0).n_components() == 1,
ExcMessage(
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_difference(
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
const Function<spacedim, typename VectorType::value_type> &exact_function,
- Vector<typename VectorType::value_type> & difference,
- const Point<spacedim> & point)
+ Vector<typename VectorType::value_type> &difference,
+ const Point<spacedim> &point)
{
point_difference(StaticMappingQ1<dim>::mapping,
dof,
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_dealii_vector_type<VectorType>)
void point_difference(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const VectorType & fe_function,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const VectorType &fe_function,
const Function<spacedim, typename VectorType::value_type> &exact_function,
- Vector<typename VectorType::value_type> & difference,
- const Point<spacedim> & point)
+ Vector<typename VectorType::value_type> &difference,
+ const Point<spacedim> &point)
{
using Number = typename VectorType::value_type;
const FiniteElement<dim> &fe = dof.get_fe();
template <int dim, int spacedim>
void
- create_point_source_vector(const Mapping<dim, spacedim> & mapping,
+ create_point_source_vector(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const Point<spacedim> & p,
- Vector<double> & rhs_vector)
+ const Point<spacedim> &p,
+ Vector<double> &rhs_vector)
{
Assert(rhs_vector.size() == dof_handler.n_dofs(),
ExcDimensionMismatch(rhs_vector.size(), dof_handler.n_dofs()));
template <int dim, int spacedim>
void
create_point_source_vector(const DoFHandler<dim, spacedim> &dof_handler,
- const Point<spacedim> & p,
- Vector<double> & rhs_vector)
+ const Point<spacedim> &p,
+ Vector<double> &rhs_vector)
{
if (dof_handler.has_hp_capabilities())
create_point_source_vector(
void
create_point_source_vector(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const Point<spacedim> & p,
- Vector<double> & rhs_vector)
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const Point<spacedim> &p,
+ Vector<double> &rhs_vector)
{
Assert(rhs_vector.size() == dof_handler.n_dofs(),
ExcDimensionMismatch(rhs_vector.size(), dof_handler.n_dofs()));
template <int dim, int spacedim>
void
- create_point_source_vector(const Mapping<dim, spacedim> & mapping,
+ create_point_source_vector(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const Point<spacedim> & p,
- const Point<dim> & orientation,
- Vector<double> & rhs_vector)
+ const Point<spacedim> &p,
+ const Point<dim> &orientation,
+ Vector<double> &rhs_vector)
{
Assert(rhs_vector.size() == dof_handler.n_dofs(),
ExcDimensionMismatch(rhs_vector.size(), dof_handler.n_dofs()));
template <int dim, int spacedim>
void
create_point_source_vector(const DoFHandler<dim, spacedim> &dof_handler,
- const Point<spacedim> & p,
- const Point<dim> & orientation,
- Vector<double> & rhs_vector)
+ const Point<spacedim> &p,
+ const Point<dim> &orientation,
+ Vector<double> &rhs_vector)
{
if (dof_handler.has_hp_capabilities())
create_point_source_vector(
void
create_point_source_vector(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const Point<spacedim> & p,
- const Point<dim> & orientation,
- Vector<double> & rhs_vector)
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const Point<spacedim> &p,
+ const Point<dim> &orientation,
+ Vector<double> &rhs_vector)
{
Assert(rhs_vector.size() == dof_handler.n_dofs(),
ExcDimensionMismatch(rhs_vector.size(), dof_handler.n_dofs()));
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const AffineConstraints<typename VectorType::value_type> & constraints,
- const Quadrature<dim> & quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const AffineConstraints<typename VectorType::value_type> &constraints,
+ const Quadrature<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
+ VectorType &vec,
const bool enforce_zero_boundary = false,
const Quadrature<dim - 1> &q_boundary = (dim > 1 ? QGauss<dim - 1>(2) :
Quadrature<dim - 1>(0)),
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project(
- const DoFHandler<dim, spacedim> & dof,
- const AffineConstraints<typename VectorType::value_type> & constraints,
- const Quadrature<dim> & quadrature,
+ const DoFHandler<dim, spacedim> &dof,
+ const AffineConstraints<typename VectorType::value_type> &constraints,
+ const Quadrature<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
+ VectorType &vec,
const bool enforce_zero_boundary = false,
const Quadrature<dim - 1> &q_boundary = (dim > 1 ? QGauss<dim - 1>(2) :
Quadrature<dim - 1>(0)),
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const AffineConstraints<typename VectorType::value_type> & constraints,
- const hp::QCollection<dim> & quadrature,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const AffineConstraints<typename VectorType::value_type> &constraints,
+ const hp::QCollection<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
+ VectorType &vec,
const bool enforce_zero_boundary = false,
const hp::QCollection<dim - 1> &q_boundary = hp::QCollection<dim - 1>(
dim > 1 ? QGauss<dim - 1>(2) : Quadrature<dim - 1>(0)),
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project(
- const DoFHandler<dim, spacedim> & dof,
- const AffineConstraints<typename VectorType::value_type> & constraints,
- const hp::QCollection<dim> & quadrature,
+ const DoFHandler<dim, spacedim> &dof,
+ const AffineConstraints<typename VectorType::value_type> &constraints,
+ const hp::QCollection<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
+ VectorType &vec,
const bool enforce_zero_boundary = false,
const hp::QCollection<dim - 1> &q_boundary = hp::QCollection<dim - 1>(
dim > 1 ? QGauss<dim - 1>(2) : Quadrature<dim - 1>(0)),
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
const AffineConstraints<typename VectorType::value_type> &constraints,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const std::function<typename VectorType::value_type(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &,
- const unsigned int)> & func,
- VectorType & vec_result);
+ const unsigned int)> &func,
+ VectorType &vec_result);
/**
* The same as above for projection of scalar-valued MatrixFree quadrature
const unsigned int n_q_points_1d,
const std::function<VectorizedArray<typename VectorType::value_type>(
const unsigned int,
- const unsigned int)> & func,
- VectorType & vec_result,
+ const unsigned int)> &func,
+ VectorType &vec_result,
const unsigned int fe_component = 0);
/**
const AffineConstraints<typename VectorType::value_type> &constraints,
const std::function<VectorizedArray<typename VectorType::value_type>(
const unsigned int,
- const unsigned int)> & func,
- VectorType & vec_result,
+ const unsigned int)> &func,
+ VectorType &vec_result,
const unsigned int fe_component = 0);
/** @} */
template <int dim, int spacedim, typename Number>
void
interpolate_zero_boundary_values(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
std::map<types::global_dof_index, Number> &boundary_values)
{
// loop over all boundary faces
typename Number>
void
project_compute_b_v(
- const M_or_MC<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Function<spacedim, Number> & function,
+ const M_or_MC<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const Function<spacedim, Number> &function,
const bool enforce_zero_boundary,
- const Q_or_QC<dim - 1> & q_boundary,
+ const Q_or_QC<dim - 1> &q_boundary,
const bool project_to_boundary_first,
std::map<types::global_dof_index, Number> &boundary_values)
{
else
// no homogeneous boundary values
if (project_to_boundary_first == true)
- // boundary projection required
- {
- // set up a list of boundary
- // functions for the
- // different boundary
- // parts. We want the
- // function to hold on
- // all parts of the boundary
- const std::vector<types::boundary_id> used_boundary_ids =
- dof.get_triangulation().get_boundary_ids();
-
- std::map<types::boundary_id, const Function<spacedim, Number> *>
- boundary_functions;
- for (const auto used_boundary_id : used_boundary_ids)
- boundary_functions[used_boundary_id] = &function;
- project_boundary_values(
- mapping, dof, boundary_functions, q_boundary, boundary_values);
- }
+ // boundary projection required
+ {
+ // set up a list of boundary
+ // functions for the
+ // different boundary
+ // parts. We want the
+ // function to hold on
+ // all parts of the boundary
+ const std::vector<types::boundary_id> used_boundary_ids =
+ dof.get_triangulation().get_boundary_ids();
+
+ std::map<types::boundary_id, const Function<spacedim, Number> *>
+ boundary_functions;
+ for (const auto used_boundary_id : used_boundary_ids)
+ boundary_functions[used_boundary_id] = &function;
+ project_boundary_values(
+ mapping, dof, boundary_functions, q_boundary, boundary_values);
+ }
}
template <int components, int dim, typename Number, int spacedim>
void
project_matrix_free(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const AffineConstraints<Number> &constraints,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const Function<
spacedim,
typename LinearAlgebra::distributed::Vector<Number>::value_type>
- & function,
+ &function,
LinearAlgebra::distributed::Vector<Number> &work_result,
const bool enforce_zero_boundary,
- const Quadrature<dim - 1> & q_boundary,
+ const Quadrature<dim - 1> &q_boundary,
const bool project_to_boundary_first)
{
Assert(project_to_boundary_first == false, ExcNotImplemented());
template <int dim, typename Number, int spacedim>
void
project_matrix_free_component(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const AffineConstraints<Number> &constraints,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const Function<
spacedim,
typename LinearAlgebra::distributed::Vector<Number>::value_type>
- & function,
+ &function,
LinearAlgebra::distributed::Vector<Number> &work_result,
const bool enforce_zero_boundary,
- const Quadrature<dim - 1> & q_boundary,
+ const Quadrature<dim - 1> &q_boundary,
const bool project_to_boundary_first)
{
switch (dof.get_fe(0).n_components())
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project_matrix_free_copy_vector(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const AffineConstraints<typename VectorType::value_type> & constraints,
- const Quadrature<dim> & quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const AffineConstraints<typename VectorType::value_type> &constraints,
+ const Quadrature<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec_result,
+ VectorType &vec_result,
const bool enforce_zero_boundary,
const Quadrature<dim - 1> &q_boundary,
const bool project_to_boundary_first)
template <typename Number>
bool
constraints_and_b_v_are_compatible(
- const AffineConstraints<Number> & constraints,
+ const AffineConstraints<Number> &constraints,
std::map<types::global_dof_index, Number> &boundary_values)
{
for (const auto &boundary_value : boundary_values)
class Q_or_QC>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void do_project(
- const M_or_MC<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const AffineConstraints<typename VectorType::value_type> & constraints,
- const Q_or_QC<dim> & quadrature,
+ const M_or_MC<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const AffineConstraints<typename VectorType::value_type> &constraints,
+ const Q_or_QC<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec_result,
+ VectorType &vec_result,
const bool enforce_zero_boundary,
const Q_or_QC<dim - 1> &q_boundary,
const bool project_to_boundary_first)
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project_parallel(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
const AffineConstraints<typename VectorType::value_type> &constraints,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const std::function<typename VectorType::value_type(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &,
- const unsigned int)> & func,
- VectorType & vec_result)
+ const unsigned int)> &func,
+ VectorType &vec_result)
{
using Number = typename VectorType::value_type;
using LocalVectorType = LinearAlgebra::distributed::Vector<Number>;
constraints.distribute(vec);
- const IndexSet & locally_owned_dofs = dof.locally_owned_dofs();
+ const IndexSet &locally_owned_dofs = dof.locally_owned_dofs();
IndexSet::ElementIterator it = locally_owned_dofs.begin();
for (; it != locally_owned_dofs.end(); ++it)
::dealii::internal::ElementAccess<VectorType>::set(vec(*it),
const AffineConstraints<typename VectorType::value_type> &constraints,
const std::function<VectorizedArray<typename VectorType::value_type>(
const unsigned int,
- const unsigned int)> & func,
- VectorType & vec_result,
+ const unsigned int)> &func,
+ VectorType &vec_result,
const unsigned int fe_component)
{
const DoFHandler<dim, spacedim> &dof =
constraints.distribute(vec);
- const IndexSet & locally_owned_dofs = dof.locally_owned_dofs();
+ const IndexSet &locally_owned_dofs = dof.locally_owned_dofs();
IndexSet::ElementIterator it = locally_owned_dofs.begin();
for (; it != locally_owned_dofs.end(); ++it)
::dealii::internal::ElementAccess<VectorType>::set(vec(*it),
std::enable_if_t<
!numbers::NumberTraits<typename VectorType::value_type>::is_complex &&
(dim == spacedim),
- void> project(const Mapping<dim, spacedim> & mapping,
+ void> project(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const AffineConstraints<typename VectorType::value_type>
- & constraints,
+ &constraints,
const Quadrature<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type>
- & function,
- VectorType & vec_result,
+ &function,
+ VectorType &vec_result,
const bool enforce_zero_boundary,
const Quadrature<dim - 1> &q_boundary,
const bool project_to_boundary_first)
std::enable_if_t<
numbers::NumberTraits<typename VectorType::value_type>::is_complex ||
(dim < spacedim),
- void> project(const Mapping<dim, spacedim> & mapping,
+ void> project(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
const AffineConstraints<typename VectorType::value_type>
- & constraints,
+ &constraints,
const Quadrature<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type>
- & function,
- VectorType & vec_result,
+ &function,
+ VectorType &vec_result,
const bool enforce_zero_boundary,
const Quadrature<dim - 1> &q_boundary,
const bool project_to_boundary_first)
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
const AffineConstraints<typename VectorType::value_type> &constraints,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const std::function<typename VectorType::value_type(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &,
- const unsigned int)> & func,
- VectorType & vec_result)
+ const unsigned int)> &func,
+ VectorType &vec_result)
{
internal::project_parallel<dim, VectorType, spacedim>(
mapping, dof, constraints, quadrature, func, vec_result);
const std::function<VectorizedArray<typename VectorType::value_type>(
const unsigned int,
const unsigned int)> &func,
- VectorType & vec_result,
+ VectorType &vec_result,
const unsigned int fe_component)
{
internal::project_parallel<dim, VectorType, dim>(
const AffineConstraints<typename VectorType::value_type> &constraints,
const std::function<VectorizedArray<typename VectorType::value_type>(
const unsigned int,
- const unsigned int)> & func,
- VectorType & vec_result,
+ const unsigned int)> &func,
+ VectorType &vec_result,
const unsigned int fe_component)
{
project(matrix_free,
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const AffineConstraints<typename VectorType::value_type> & constraints,
- const Quadrature<dim> & quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const AffineConstraints<typename VectorType::value_type> &constraints,
+ const Quadrature<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec_result,
+ VectorType &vec_result,
const bool enforce_zero_boundary,
const Quadrature<dim - 1> &q_boundary,
const bool project_to_boundary_first)
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project(
- const DoFHandler<dim, spacedim> & dof,
- const AffineConstraints<typename VectorType::value_type> & constraints,
- const Quadrature<dim> & quadrature,
+ const DoFHandler<dim, spacedim> &dof,
+ const AffineConstraints<typename VectorType::value_type> &constraints,
+ const Quadrature<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
+ VectorType &vec,
const bool enforce_zero_boundary,
const Quadrature<dim - 1> &q_boundary,
const bool project_to_boundary_first)
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const AffineConstraints<typename VectorType::value_type> & constraints,
- const hp::QCollection<dim> & quadrature,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const AffineConstraints<typename VectorType::value_type> &constraints,
+ const hp::QCollection<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec_result,
+ VectorType &vec_result,
const bool enforce_zero_boundary,
const hp::QCollection<dim - 1> &q_boundary,
const bool project_to_boundary_first)
template <int dim, typename VectorType, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void project(
- const DoFHandler<dim, spacedim> & dof,
- const AffineConstraints<typename VectorType::value_type> & constraints,
- const hp::QCollection<dim> & quadrature,
+ const DoFHandler<dim, spacedim> &dof,
+ const AffineConstraints<typename VectorType::value_type> &constraints,
+ const hp::QCollection<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &function,
- VectorType & vec,
+ VectorType &vec,
const bool enforce_zero_boundary,
const hp::QCollection<dim - 1> &q_boundary,
const bool project_to_boundary_first)
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_right_hand_side(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim> &q,
const Function<spacedim, typename VectorType::value_type> &rhs,
- VectorType & rhs_vector,
- const AffineConstraints<typename VectorType::value_type> & constraints =
+ VectorType &rhs_vector,
+ const AffineConstraints<typename VectorType::value_type> &constraints =
AffineConstraints<typename VectorType::value_type>());
/**
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_right_hand_side(
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim> &q,
const Function<spacedim, typename VectorType::value_type> &rhs,
- VectorType & rhs_vector,
- const AffineConstraints<typename VectorType::value_type> & constraints =
+ VectorType &rhs_vector,
+ const AffineConstraints<typename VectorType::value_type> &constraints =
AffineConstraints<typename VectorType::value_type>());
/**
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_right_hand_side(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
const Function<spacedim, typename VectorType::value_type> &rhs,
- VectorType & rhs_vector,
- const AffineConstraints<typename VectorType::value_type> & constraints =
+ VectorType &rhs_vector,
+ const AffineConstraints<typename VectorType::value_type> &constraints =
AffineConstraints<typename VectorType::value_type>());
/**
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_right_hand_side(
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim> &q,
const Function<spacedim, typename VectorType::value_type> &rhs,
- VectorType & rhs_vector,
- const AffineConstraints<typename VectorType::value_type> & constraints =
+ VectorType &rhs_vector,
+ const AffineConstraints<typename VectorType::value_type> &constraints =
AffineConstraints<typename VectorType::value_type>());
/**
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_boundary_right_hand_side(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim - 1> & q,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim - 1> &q,
const Function<spacedim, typename VectorType::value_type> &rhs,
- VectorType & rhs_vector,
- const std::set<types::boundary_id> & boundary_ids =
+ VectorType &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids =
std::set<types::boundary_id>());
/**
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_boundary_right_hand_side(
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim - 1> & q,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim - 1> &q,
const Function<spacedim, typename VectorType::value_type> &rhs,
- VectorType & rhs_vector,
- const std::set<types::boundary_id> & boundary_ids =
+ VectorType &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids =
std::set<types::boundary_id>());
/**
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_boundary_right_hand_side(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim - 1> & q,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim - 1> &q,
const Function<spacedim, typename VectorType::value_type> &rhs,
- VectorType & rhs_vector,
- const std::set<types::boundary_id> & boundary_ids =
+ VectorType &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids =
std::set<types::boundary_id>());
/**
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_boundary_right_hand_side(
- const DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim - 1> & q,
+ const DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim - 1> &q,
const Function<spacedim, typename VectorType::value_type> &rhs,
- VectorType & rhs_vector,
- const std::set<types::boundary_id> & boundary_ids =
+ VectorType &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids =
std::set<types::boundary_id>());
/** @} */
} // namespace VectorTools
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_boundary_right_hand_side(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const Quadrature<dim - 1> & quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const Quadrature<dim - 1> &quadrature,
const Function<spacedim, typename VectorType::value_type> &rhs_function,
- VectorType & rhs_vector,
- const std::set<types::boundary_id> & boundary_ids)
+ VectorType &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
AssertDimension(fe.n_components(), rhs_function.n_components);
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_boundary_right_hand_side(
- const DoFHandler<dim, spacedim> & dof_handler,
- const Quadrature<dim - 1> & quadrature,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const Quadrature<dim - 1> &quadrature,
const Function<spacedim, typename VectorType::value_type> &rhs_function,
- VectorType & rhs_vector,
- const std::set<types::boundary_id> & boundary_ids)
+ VectorType &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids)
{
create_boundary_right_hand_side(StaticMappingQ1<dim>::mapping,
dof_handler,
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_boundary_right_hand_side(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const hp::QCollection<dim - 1> &quadrature,
const Function<spacedim, typename VectorType::value_type> &rhs_function,
- VectorType & rhs_vector,
- const std::set<types::boundary_id> & boundary_ids)
+ VectorType &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids)
{
const hp::FECollection<dim> &fe = dof_handler.get_fe_collection();
AssertDimension(fe.n_components(), rhs_function.n_components);
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_boundary_right_hand_side(
- const DoFHandler<dim, spacedim> & dof_handler,
- const hp::QCollection<dim - 1> & quadrature,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const hp::QCollection<dim - 1> &quadrature,
const Function<spacedim, typename VectorType::value_type> &rhs_function,
- VectorType & rhs_vector,
- const std::set<types::boundary_id> & boundary_ids)
+ VectorType &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids)
{
create_boundary_right_hand_side(
hp::StaticMappingQ1<dim>::mapping_collection,
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_right_hand_side(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const Quadrature<dim> & quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const Quadrature<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &rhs_function,
- VectorType & rhs_vector,
- const AffineConstraints<typename VectorType::value_type> & constraints)
+ VectorType &rhs_vector,
+ const AffineConstraints<typename VectorType::value_type> &constraints)
{
using Number = typename VectorType::value_type;
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_right_hand_side(
- const DoFHandler<dim, spacedim> & dof_handler,
- const Quadrature<dim> & quadrature,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const Quadrature<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &rhs_function,
- VectorType & rhs_vector,
- const AffineConstraints<typename VectorType::value_type> & constraints)
+ VectorType &rhs_vector,
+ const AffineConstraints<typename VectorType::value_type> &constraints)
{
create_right_hand_side(get_default_linear_mapping(
dof_handler.get_triangulation()),
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_right_hand_side(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const hp::QCollection<dim> & quadrature,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const hp::QCollection<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &rhs_function,
- VectorType & rhs_vector,
- const AffineConstraints<typename VectorType::value_type> & constraints)
+ VectorType &rhs_vector,
+ const AffineConstraints<typename VectorType::value_type> &constraints)
{
using Number = typename VectorType::value_type;
template <int dim, int spacedim, typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void create_right_hand_side(
- const DoFHandler<dim, spacedim> & dof_handler,
- const hp::QCollection<dim> & quadrature,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const hp::QCollection<dim> &quadrature,
const Function<spacedim, typename VectorType::value_type> &rhs_function,
- VectorType & rhs_vector,
- const AffineConstraints<typename VectorType::value_type> & constraints)
+ VectorType &rhs_vector,
+ const AffineConstraints<typename VectorType::value_type> &constraints)
{
create_right_hand_side(
hp::StaticMappingQ1<dim, spacedim>::mapping_collection,
virtual Point<spacedim>
project_to_manifold(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Point<spacedim> & candidate) const override;
+ const Point<spacedim> &candidate) const override;
protected:
* Construct a Manifold object which will project points on the
* TopoDS_Shape @p sh, along the given @p direction.
*/
- DirectionalProjectionManifold(const TopoDS_Shape & sh,
+ DirectionalProjectionManifold(const TopoDS_Shape &sh,
const Tensor<1, spacedim> &direction,
const double tolerance = 1e-7);
virtual Point<spacedim>
project_to_manifold(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Point<spacedim> & candidate) const override;
+ const Point<spacedim> &candidate) const override;
protected:
/**
virtual Point<spacedim>
project_to_manifold(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Point<spacedim> & candidate) const override;
+ const Point<spacedim> &candidate) const override;
protected:
/**
*/
void
write_STL(const TopoDS_Shape &shape,
- const std::string & filename,
+ const std::string &filename,
const double deflection,
const bool sew_different_faces = false,
const double sewer_tolerance = 1e-6,
template <int dim>
TopoDS_Edge
interpolation_curve(std::vector<Point<dim>> &curve_points,
- const Tensor<1, dim> & direction = Tensor<1, dim>(),
+ const Tensor<1, dim> &direction = Tensor<1, dim>(),
const bool closed = false,
const double tolerance = 1e-7);
* shape, the respective container will be empty.
*/
void
- extract_geometrical_shapes(const TopoDS_Shape & shape,
- std::vector<TopoDS_Face> & faces,
- std::vector<TopoDS_Edge> & edges,
+ extract_geometrical_shapes(const TopoDS_Shape &shape,
+ std::vector<TopoDS_Face> &faces,
+ std::vector<TopoDS_Edge> &edges,
std::vector<TopoDS_Vertex> &vertices);
/**
*/
template <int spacedim>
void
- create_triangulation(const TopoDS_Face & face,
+ create_triangulation(const TopoDS_Face &face,
Triangulation<2, spacedim> &tria);
std::vector<TopoDS_Edge>
create_curves_from_triangulation_boundary(
const Triangulation<2, spacedim> &triangulation,
- const Mapping<2, spacedim> & mapping =
+ const Mapping<2, spacedim> &mapping =
StaticMappingQ1<2, spacedim>::mapping);
/**
* compound, the respective container will be empty.
*/
void
- extract_compound_shapes(const TopoDS_Shape & shape,
- std::vector<TopoDS_Compound> & compounds,
+ extract_compound_shapes(const TopoDS_Shape &shape,
+ std::vector<TopoDS_Compound> &compounds,
std::vector<TopoDS_CompSolid> &compsolids,
- std::vector<TopoDS_Solid> & solids,
- std::vector<TopoDS_Shell> & shells,
- std::vector<TopoDS_Wire> & wires);
+ std::vector<TopoDS_Solid> &solids,
+ std::vector<TopoDS_Shell> &shells,
+ std::vector<TopoDS_Wire> &wires);
/**
* Project the point @p origin on the topological shape given by @p
template <int dim>
std::tuple<Point<dim>, TopoDS_Shape, double, double>
project_point_and_pull_back(const TopoDS_Shape &in_shape,
- const Point<dim> & origin,
+ const Point<dim> &origin,
const double tolerance = 1e-7);
/**
template <int dim>
Point<dim>
closest_point(const TopoDS_Shape &in_shape,
- const Point<dim> & origin,
+ const Point<dim> &origin,
const double tolerance = 1e-7);
/**
*/
std::tuple<Point<3>, Tensor<1, 3>, double, double>
closest_point_and_differential_forms(const TopoDS_Shape &in_shape,
- const Point<3> & origin,
+ const Point<3> &origin,
const double tolerance = 1e-7);
*/
template <int dim>
Point<dim>
- line_intersection(const TopoDS_Shape & in_shape,
- const Point<dim> & origin,
+ line_intersection(const TopoDS_Shape &in_shape,
+ const Point<dim> &origin,
const Tensor<1, dim> &direction,
const double tolerance = 1e-7);
*/
template <int dim>
bool
- point_compare(const Point<dim> & p1,
- const Point<dim> & p2,
+ point_compare(const Point<dim> &p1,
+ const Point<dim> &p2,
const Tensor<1, dim> &direction = Tensor<1, dim>(),
const double tolerance = 1e-10);
const NumberType x_hi,
const NumberType f_hi,
const NumberType g_hi,
- const FiniteSizeHistory<NumberType> & x_rec,
- const FiniteSizeHistory<NumberType> & f_rec,
- const FiniteSizeHistory<NumberType> & g_rec,
+ const FiniteSizeHistory<NumberType> &x_rec,
+ const FiniteSizeHistory<NumberType> &f_rec,
+ const FiniteSizeHistory<NumberType> &g_rec,
const std::pair<NumberType, NumberType> bounds);
/**
const NumberType x_hi,
const NumberType f_hi,
const NumberType g_hi,
- const FiniteSizeHistory<NumberType> & x_rec,
- const FiniteSizeHistory<NumberType> & f_rec,
- const FiniteSizeHistory<NumberType> & g_rec,
+ const FiniteSizeHistory<NumberType> &x_rec,
+ const FiniteSizeHistory<NumberType> &f_rec,
+ const FiniteSizeHistory<NumberType> &g_rec,
const std::pair<NumberType, NumberType> bounds);
std::pair<NumberType, unsigned int>
line_search(
const std::function<std::pair<NumberType, NumberType>(const NumberType x)>
- & func,
+ &func,
const NumberType f0,
const NumberType g0,
const std::function<
const NumberType x_hi,
const NumberType f_hi,
const NumberType g_hi,
- const FiniteSizeHistory<NumberType> & x_rec,
- const FiniteSizeHistory<NumberType> & f_rec,
- const FiniteSizeHistory<NumberType> & g_rec,
+ const FiniteSizeHistory<NumberType> &x_rec,
+ const FiniteSizeHistory<NumberType> &f_rec,
+ const FiniteSizeHistory<NumberType> &g_rec,
const std::pair<NumberType, NumberType> bounds)> &interpolate,
const NumberType a1,
const NumberType eta = 0.9,
std::pair<NumberType, unsigned int>
line_search(
const std::function<std::pair<NumberType, NumberType>(const NumberType x)>
- & func,
+ &func,
const NumberType f0,
const NumberType g0,
const std::function<
const NumberType x_hi,
const NumberType f_hi,
const NumberType g_hi,
- const FiniteSizeHistory<NumberType> & x_rec,
- const FiniteSizeHistory<NumberType> & f_rec,
- const FiniteSizeHistory<NumberType> & g_rec,
+ const FiniteSizeHistory<NumberType> &x_rec,
+ const FiniteSizeHistory<NumberType> &f_rec,
+ const FiniteSizeHistory<NumberType> &g_rec,
const std::pair<NumberType, NumberType> bounds)> &choose,
const NumberType a1,
const NumberType eta,
*/
void
applyBinary(const ROL::Elementwise::BinaryFunction<value_type> &f,
- const ROL::Vector<value_type> & rol_vector);
+ const ROL::Vector<value_type> &rol_vector);
/**
* Return the accumulated value on applying reduction operation @p r on
void
VectorAdaptor<VectorType>::applyBinary(
const ROL::Elementwise::BinaryFunction<value_type> &f,
- const ROL::Vector<value_type> & rol_vector)
+ const ROL::Vector<value_type> &rol_vector)
{
Assert(this->dimension() == rol_vector.dimension(),
ExcDimensionMismatch(this->dimension(), rol_vector.dimension()));
/**
* Constructor.
*/
- explicit SolverBFGS(SolverControl & residual_control,
+ explicit SolverBFGS(SolverControl &residual_control,
const AdditionalData &data = AdditionalData());
/**
void
solve(
const std::function<Number(const VectorType &x, VectorType &g)> &compute,
- VectorType & x);
+ VectorType &x);
/**
* Connect a slot to perform a custom line-search.
*/
boost::signals2::connection
connect_preconditioner_slot(
- const std::function<void(VectorType & g,
+ const std::function<void(VectorType &g,
const FiniteSizeHistory<VectorType> &s,
const FiniteSizeHistory<VectorType> &y)> &slot);
/**
* Signal used to perform preconditioning.
*/
- boost::signals2::signal<void(VectorType & g,
+ boost::signals2::signal<void(VectorType &g,
const FiniteSizeHistory<VectorType> &s,
const FiniteSizeHistory<VectorType> &y)>
preconditioner_signal;
template <typename VectorType>
-SolverBFGS<VectorType>::SolverBFGS(SolverControl & solver_control,
+SolverBFGS<VectorType>::SolverBFGS(SolverControl &solver_control,
const AdditionalData &data)
: SolverBase<VectorType>(solver_control)
, additional_data(data)
template <typename VectorType>
boost::signals2::connection
SolverBFGS<VectorType>::connect_preconditioner_slot(
- const std::function<void(VectorType & g,
+ const std::function<void(VectorType &g,
const FiniteSizeHistory<VectorType> &s,
const FiniteSizeHistory<VectorType> &y)> &slot)
{
SolverBFGS<VectorType>::solve(
const std::function<typename VectorType::value_type(const VectorType &x,
VectorType &f)> &compute,
- VectorType & x)
+ VectorType &x)
{
// Also see scipy Fortran implementation
// https://github.com/scipy/scipy/blob/master/scipy/optimize/lbfgsb_src/lbfgsb.f
void
regular_reference_locations(
const Triangulation<dim, spacedim> &triangulation,
- const std::vector<Point<dim>> & particle_reference_locations,
- ParticleHandler<dim, spacedim> & particle_handler,
- const Mapping<dim, spacedim> & mapping =
+ const std::vector<Point<dim>> &particle_reference_locations,
+ ParticleHandler<dim, spacedim> &particle_handler,
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()
random_particle_in_cell(
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
const types::particle_index id,
- std::mt19937 & random_number_generator,
+ std::mt19937 &random_number_generator,
const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
random_particle_in_cell_insert(
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
const types::particle_index id,
- std::mt19937 & random_number_generator,
+ std::mt19937 &random_number_generator,
ParticleHandler<dim, spacedim> &particle_handler,
- const Mapping<dim, spacedim> & mapping =
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()
void
probabilistic_locations(
const Triangulation<dim, spacedim> &triangulation,
- const Function<spacedim> & probability_density_function,
+ const Function<spacedim> &probability_density_function,
const bool random_cell_selection,
const types::particle_index n_particles_to_create,
- ParticleHandler<dim, spacedim> & particle_handler,
- const Mapping<dim, spacedim> & mapping =
+ ParticleHandler<dim, spacedim> &particle_handler,
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()),
dof_support_points(
const DoFHandler<dim, spacedim> &dof_handler,
const std::vector<std::vector<BoundingBox<spacedim>>>
- & global_bounding_boxes,
+ &global_bounding_boxes,
ParticleHandler<dim, spacedim> &particle_handler,
- const Mapping<dim, spacedim> & mapping =
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
#ifndef _MSC_VER
.template get_default_linear_mapping<dim, spacedim>()),
#else
.ReferenceCell::get_default_linear_mapping<dim, spacedim>()),
#endif
- const ComponentMask & components = {},
+ const ComponentMask &components = {},
const std::vector<std::vector<double>> &properties = {});
/**
void
quadrature_points(
const Triangulation<dim, spacedim> &triangulation,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const std::vector<std::vector<BoundingBox<spacedim>>>
- & global_bounding_boxes,
+ &global_bounding_boxes,
ParticleHandler<dim, spacedim> &particle_handler,
- const Mapping<dim, spacedim> & mapping =
+ const Mapping<dim, spacedim> &mapping =
(ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()),
const std::vector<std::vector<double>> &properties = {});
* in the coordinate system of the reference cell.
* @param[in] id Globally unique ID number of particle.
*/
- Particle(const Point<spacedim> & location,
- const Point<dim> & reference_location,
+ Particle(const Point<spacedim> &location,
+ const Point<dim> &reference_location,
const types::particle_index id);
/**
* succeed if a property pool is provided as second argument that is able to
* store the correct number of properties per particle.
*/
- Particle(const void *& begin_data,
+ Particle(const void *&begin_data,
PropertyPool<dim, spacedim> *const property_pool = nullptr);
/**
{
unsigned int n_properties = 0;
- Point<spacedim> location;
- Point<dim> reference_location;
- types::particle_index id;
+ Point<spacedim> location;
+ Point<dim> reference_location;
+ types::particle_index id;
ar &location &reference_location &id &n_properties;
set_location(location);
*/
ParticleAccessor(
const typename particle_container::iterator particles_in_cell,
- const PropertyPool<dim, spacedim> & property_pool,
+ const PropertyPool<dim, spacedim> &property_pool,
const unsigned int particle_index_within_cell);
/**
{
unsigned int n_properties = 0;
- Point<spacedim> location;
- Point<dim> reference_location;
- types::particle_index id;
+ Point<spacedim> location;
+ Point<dim> reference_location;
+ types::particle_index id;
ar &location &reference_location &id &n_properties;
set_location(location);
template <int dim, int spacedim>
inline ParticleAccessor<dim, spacedim>::ParticleAccessor(
const typename particle_container::iterator particles_in_cell,
- const PropertyPool<dim, spacedim> & property_pool,
+ const PropertyPool<dim, spacedim> &property_pool,
const unsigned int particle_index_within_cell)
: particles_in_cell(particles_in_cell)
, property_pool(const_cast<PropertyPool<dim, spacedim> *>(&property_pool))
* the initialize function.
*/
ParticleHandler(const Triangulation<dim, spacedim> &tria,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const unsigned int n_properties = 0);
/**
*/
void
initialize(const Triangulation<dim, spacedim> &tria,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const unsigned int n_properties = 0);
/**
*/
particle_iterator
insert_particle(
- const Point<spacedim> & position,
- const Point<dim> & reference_position,
+ const Point<spacedim> &position,
+ const Point<dim> &reference_position,
const types::particle_index particle_index,
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
const ArrayView<const double> &properties = {});
insert_global_particles(
const std::vector<Point<spacedim>> &positions,
const std::vector<std::vector<BoundingBox<spacedim>>>
- & global_bounding_boxes,
- const std::vector<std::vector<double>> & properties = {},
+ &global_bounding_boxes,
+ const std::vector<std::vector<double>> &properties = {},
const std::vector<types::particle_index> &ids = {});
/**
*/
particle_iterator
insert_particle(
- const void *& data,
+ const void *&data,
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell);
/**
// the domain is distributed differently after resuming from a checkpoint.
ar //&particles
&global_number_of_particles &global_max_particles_per_cell
- & next_free_particle_index;
+ &next_free_particle_index;
}
*/
ParticleIterator(
const typename particle_container::iterator particles_in_cell,
- const PropertyPool<dim, spacedim> & property_pool,
+ const PropertyPool<dim, spacedim> &property_pool,
const unsigned int particle_index_within_cell);
/**
template <int dim, int spacedim>
inline ParticleIterator<dim, spacedim>::ParticleIterator(
const typename particle_container::iterator particles_in_cell,
- const PropertyPool<dim, spacedim> & property_pool,
+ const PropertyPool<dim, spacedim> &property_pool,
const unsigned int particle_index_within_cell)
: accessor(particles_in_cell, property_pool, particle_index_within_cell)
{}
ParticleIterator<dim, spacedim>::operator++(int)
{
ParticleIterator tmp(*this);
- operator++();
+ operator++();
return tmp;
}
ParticleIterator<dim, spacedim>::operator--(int)
{
ParticleIterator tmp(*this);
- operator--();
+ operator--();
return tmp;
}
template <int dim, int spacedim, typename number = double>
void
create_interpolation_sparsity_pattern(
- const DoFHandler<dim, spacedim> & space_dh,
+ const DoFHandler<dim, spacedim> &space_dh,
const Particles::ParticleHandler<dim, spacedim> &particle_handler,
- SparsityPatternBase & sparsity,
- const AffineConstraints<number> & constraints =
+ SparsityPatternBase &sparsity,
+ const AffineConstraints<number> &constraints =
AffineConstraints<number>(),
const ComponentMask &space_comps = {});
template <int dim, int spacedim, typename MatrixType>
void
create_interpolation_matrix(
- const DoFHandler<dim, spacedim> & space_dh,
+ const DoFHandler<dim, spacedim> &space_dh,
const Particles::ParticleHandler<dim, spacedim> &particle_handler,
- MatrixType & matrix,
+ MatrixType &matrix,
const AffineConstraints<typename MatrixType::value_type> &constraints =
AffineConstraints<typename MatrixType::value_type>(),
const ComponentMask &space_comps = {});
typename OutputVectorType>
void
interpolate_field_on_particles(
- const DoFHandler<dim, spacedim> & field_dh,
+ const DoFHandler<dim, spacedim> &field_dh,
const Particles::ParticleHandler<dim, spacedim> &particle_handler,
- const InputVectorType & field_vector,
- OutputVectorType & interpolated_field,
- const ComponentMask & field_comps = {})
+ const InputVectorType &field_vector,
+ OutputVectorType &interpolated_field,
+ const ComponentMask &field_comps = {})
{
if (particle_handler.n_locally_owned_particles() == 0)
{
*/
template <int dim, typename Number>
void
- to_tensor(const FullMatrix<Number> & mtrx,
+ to_tensor(const FullMatrix<Number> &mtrx,
SymmetricTensor<2, dim, Number> &st);
*/
template <int dim, typename Number>
void
- to_tensor(const FullMatrix<Number> & mtrx,
+ to_tensor(const FullMatrix<Number> &mtrx,
SymmetricTensor<4, dim, Number> &st);
template <int dim, typename Number>
void
- to_tensor(const FullMatrix<Number> & mtrx,
+ to_tensor(const FullMatrix<Number> &mtrx,
SymmetricTensor<2, dim, Number> &st)
{
// Its impossible to fit the (dim^2 + dim)/2 entries into a square
template <int dim, typename Number>
void
- to_tensor(const FullMatrix<Number> & mtrx,
+ to_tensor(const FullMatrix<Number> &mtrx,
SymmetricTensor<4, dim, Number> &st)
{
Assert((mtrx.m() ==
template <int dim, typename Number>
SymmetricTensor<2, dim, Number>
push_forward(const SymmetricTensor<2, dim, Number> &T,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/**
* Return the result of the push forward transformation on a rank-4
template <int dim, typename Number>
SymmetricTensor<4, dim, Number>
push_forward(const SymmetricTensor<4, dim, Number> &H,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/** @} */
template <int dim, typename Number>
SymmetricTensor<2, dim, Number>
pull_back(const SymmetricTensor<2, dim, Number> &t,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/**
* Return the result of the pull back transformation on a rank-4
template <int dim, typename Number>
SymmetricTensor<4, dim, Number>
pull_back(const SymmetricTensor<4, dim, Number> &h,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/** @} */
} // namespace Contravariant
template <int dim, typename Number>
SymmetricTensor<2, dim, Number>
push_forward(const SymmetricTensor<2, dim, Number> &T,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/**
* Return the result of the push forward transformation on a rank-4
template <int dim, typename Number>
SymmetricTensor<4, dim, Number>
push_forward(const SymmetricTensor<4, dim, Number> &H,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/** @} */
template <int dim, typename Number>
SymmetricTensor<2, dim, Number>
pull_back(const SymmetricTensor<2, dim, Number> &t,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/**
* Return the result of the pull back transformation on a rank-4
template <int dim, typename Number>
SymmetricTensor<4, dim, Number>
pull_back(const SymmetricTensor<4, dim, Number> &h,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/** @} */
} // namespace Covariant
template <int dim, typename Number>
SymmetricTensor<2, dim, Number>
push_forward(const SymmetricTensor<2, dim, Number> &T,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/**
* Return the result of the push forward transformation on a rank-4
template <int dim, typename Number>
SymmetricTensor<4, dim, Number>
push_forward(const SymmetricTensor<4, dim, Number> &H,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/** @} */
template <int dim, typename Number>
SymmetricTensor<2, dim, Number>
pull_back(const SymmetricTensor<2, dim, Number> &t,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/**
* Return the result of the pull back transformation on a rank-4
template <int dim, typename Number>
SymmetricTensor<4, dim, Number>
pull_back(const SymmetricTensor<4, dim, Number> &h,
- const Tensor<2, dim, Number> & F);
+ const Tensor<2, dim, Number> &F);
/** @} */
} // namespace Piola
template <int dim, typename Number>
SymmetricTensor<2, dim, Number>
basis_transformation(const SymmetricTensor<2, dim, Number> &T,
- const Tensor<2, dim, Number> & B);
+ const Tensor<2, dim, Number> &B);
/**
* Return a rank-4 tensor with a changed basis, i.e. (in index notation):
template <int dim, typename Number>
SymmetricTensor<4, dim, Number>
basis_transformation(const SymmetricTensor<4, dim, Number> &H,
- const Tensor<2, dim, Number> & B);
+ const Tensor<2, dim, Number> &B);
/** @} */
Tensor<2, 3, Number>
Physics::Transformations::Rotations::rotation_matrix_3d(
const Tensor<1, 3, Number> &axis,
- const Number & angle)
+ const Number &angle)
{
// Make things work with AD types
using std::abs;
Tensor<2, 3, Number>
Physics::Transformations::Rotations::rotation_matrix_3d(
const Point<3, Number> &axis,
- const Number & angle)
+ const Number &angle)
{
return rotation_matrix_3d(static_cast<Tensor<1, 3, Number>>(axis), angle);
}
inline SymmetricTensor<2, dim, Number>
Physics::Transformations::Contravariant::push_forward(
const SymmetricTensor<2, dim, Number> &T,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Physics::Transformations::basis_transformation(T, F);
}
inline SymmetricTensor<4, dim, Number>
Physics::Transformations::Contravariant::push_forward(
const SymmetricTensor<4, dim, Number> &H,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Physics::Transformations::basis_transformation(H, F);
}
inline SymmetricTensor<2, dim, Number>
Physics::Transformations::Contravariant::pull_back(
const SymmetricTensor<2, dim, Number> &t,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Physics::Transformations::basis_transformation(t, invert(F));
}
inline SymmetricTensor<4, dim, Number>
Physics::Transformations::Contravariant::pull_back(
const SymmetricTensor<4, dim, Number> &h,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Physics::Transformations::basis_transformation(h, invert(F));
}
inline SymmetricTensor<2, dim, Number>
Physics::Transformations::Covariant::push_forward(
const SymmetricTensor<2, dim, Number> &T,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Physics::Transformations::basis_transformation(T,
transpose(invert(F)));
inline SymmetricTensor<4, dim, Number>
Physics::Transformations::Covariant::push_forward(
const SymmetricTensor<4, dim, Number> &H,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Physics::Transformations::basis_transformation(H,
transpose(invert(F)));
inline SymmetricTensor<2, dim, Number>
Physics::Transformations::Covariant::pull_back(
const SymmetricTensor<2, dim, Number> &t,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Physics::Transformations::basis_transformation(t, transpose(F));
}
inline SymmetricTensor<4, dim, Number>
Physics::Transformations::Covariant::pull_back(
const SymmetricTensor<4, dim, Number> &h,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Physics::Transformations::basis_transformation(h, transpose(F));
}
inline SymmetricTensor<2, dim, Number>
Physics::Transformations::Piola::push_forward(
const SymmetricTensor<2, dim, Number> &T,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Number(1.0 / determinant(F)) * Contravariant::push_forward(T, F);
}
inline SymmetricTensor<4, dim, Number>
Physics::Transformations::Piola::push_forward(
const SymmetricTensor<4, dim, Number> &H,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Number(1.0 / determinant(F)) * Contravariant::push_forward(H, F);
}
inline SymmetricTensor<2, dim, Number>
Physics::Transformations::Piola::pull_back(
const SymmetricTensor<2, dim, Number> &t,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Number(determinant(F)) * Contravariant::pull_back(t, F);
}
inline SymmetricTensor<4, dim, Number>
Physics::Transformations::Piola::pull_back(
const SymmetricTensor<4, dim, Number> &h,
- const Tensor<2, dim, Number> & F)
+ const Tensor<2, dim, Number> &F)
{
return Number(determinant(F)) * Contravariant::pull_back(h, F);
}
inline SymmetricTensor<2, dim, Number>
Physics::Transformations::basis_transformation(
const SymmetricTensor<2, dim, Number> &T,
- const Tensor<2, dim, Number> & B)
+ const Tensor<2, dim, Number> &B)
{
Tensor<2, dim, Number> tmp_1;
for (unsigned int i = 0; i < dim; ++i)
inline SymmetricTensor<4, dim, Number>
Physics::Transformations::basis_transformation(
const SymmetricTensor<4, dim, Number> &H,
- const Tensor<2, dim, Number> & B)
+ const Tensor<2, dim, Number> &B)
{
// The first and last transformation operations respectively
// break and recover the symmetry properties of the tensors.
* calls to this function.
*/
unsigned int
- solve_ode_incrementally(VectorType & solution,
+ solve_ode_incrementally(VectorType &solution,
const double intermediate_time,
const bool reset_solver = false);
* can throw exceptions of type RecoverableUserCallbackError.
*/
std::function<void(const VectorType &v,
- VectorType & Jv,
+ VectorType &Jv,
const double t,
const VectorType &y,
const VectorType &fy)>
const VectorType &y,
const VectorType &fy,
const VectorType &r,
- VectorType & z,
+ VectorType &z,
const double gamma,
const double tol,
const int lr)>
const VectorType &y,
const VectorType &fy,
const int jok,
- int & jcur,
+ int &jcur,
const double gamma)>
jacobian_preconditioner_setup;
*/
std::function<void(const double t,
const VectorType &r,
- VectorType & z,
+ VectorType &z,
const double tol,
const int lr)>
mass_preconditioner_solve;
* actually been computed.
*/
std::function<void(const double t,
- const VectorType & sol,
+ const VectorType &sol,
const unsigned int step_number)>
output_step;
* Internal routine to call ARKode repeatedly.
*/
int
- do_evolve_time(VectorType & solution,
+ do_evolve_time(VectorType &solution,
dealii::DiscreteTime &time,
const bool do_reset);
std::function<void(const double t,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res)>
+ VectorType &res)>
residual;
/**
* computed.
*/
std::function<void(const double t,
- const VectorType & sol,
- const VectorType & sol_dot,
+ const VectorType &sol,
+ const VectorType &sol_dot,
const unsigned int step_number)>
output_step;
namespace NVectorOperations
{
- N_Vector_ID get_vector_id(N_Vector)
+ N_Vector_ID
+ get_vector_id(N_Vector)
{
return SUNDIALS_NVEC_CUSTOM;
}
{
// TODO copy can be avoided by a custom kernel
VectorType tmp = *unwrap_nvector_const<VectorType>(x);
- auto * w_dealii = unwrap_nvector_const<VectorType>(w);
+ auto *w_dealii = unwrap_nvector_const<VectorType>(w);
tmp.scale(*w_dealii);
return tmp.l2_norm();
}
{
// TODO copy can be avoided by a custom kernel
VectorType tmp = *unwrap_nvector_const<VectorType>(x);
- auto * w_dealii = unwrap_nvector_const<VectorType>(w);
+ auto *w_dealii = unwrap_nvector_const<VectorType>(w);
const auto n = tmp.size();
tmp.scale(*w_dealii);
return tmp.l2_norm() / std::sqrt(n);
{
// TODO copy can be avoided by a custom kernel
VectorType tmp = *unwrap_nvector_const<VectorType>(x);
- auto * w_dealii = unwrap_nvector_const<VectorType>(w);
- auto * mask_dealii = unwrap_nvector_const<VectorType>(mask);
+ auto *w_dealii = unwrap_nvector_const<VectorType>(w);
+ auto *mask_dealii = unwrap_nvector_const<VectorType>(mask);
const auto n = tmp.size();
tmp.scale(*w_dealii);
tmp.scale(*mask_dealii);
* 6.0.0. If you are using an earlier version of SUNDIALS then you need to
* use the other constructor.
*/
- SundialsPreconditioner(void * P_data,
+ SundialsPreconditioner(void *P_data,
PSolveFn p_solve_fn,
SUNContext linsol_ctx,
double tol);
*/
template <typename VectorType>
using LinearSolveFunction =
- std::function<void(SundialsOperator<VectorType> & op,
+ std::function<void(SundialsOperator<VectorType> &op,
SundialsPreconditioner<VectorType> &prec,
- VectorType & x,
- const VectorType & b,
+ VectorType &x,
+ const VectorType &b,
double tol)>;
namespace internal
public:
explicit LinearSolverWrapper(
const LinearSolveFunction<VectorType> &lsolve,
- std::exception_ptr & pending_exception
+ std::exception_ptr &pending_exception
# if DEAL_II_SUNDIALS_VERSION_GTE(6, 0, 0)
,
SUNContext linsol_ctx
*/
template <typename F, typename... Args>
int
- call_and_possibly_capture_exception(const F & f,
+ call_and_possibly_capture_exception(const F &f,
std::exception_ptr &eptr,
Args &&...args)
{
* An overview of possible parameters is given at
* https://docs.trilinos.org/dev/packages/nox/doc/html/parameters.html.
*/
- NOXSolver(AdditionalData & additional_data,
+ NOXSolver(AdditionalData &additional_data,
const Teuchos::RCP<Teuchos::ParameterList> ¶meters =
Teuchos::rcp(new Teuchos::ParameterList));
*/
std::function<SolverControl::State(const unsigned int i,
const double norm_f,
- const VectorType & current_u,
- const VectorType & f)>
+ const VectorType ¤t_u,
+ const VectorType &f)>
check_iteration_status;
/**
*/
template <typename F, typename... Args>
int
- call_and_possibly_capture_exception(const F & f,
+ call_and_possibly_capture_exception(const F &f,
std::exception_ptr &eptr,
Args &&...args)
{
* to solve the Jacobian.
*/
Group(
- VectorType & solution,
+ VectorType &solution,
const std::function<int(const VectorType &, VectorType &)> &residual,
const std::function<int(const VectorType &)> &setup_jacobian,
const std::function<int(const VectorType &, VectorType &)>
- & apply_jacobian,
+ &apply_jacobian,
const std::function<int(const VectorType &,
VectorType &,
const double)> &solve_with_jacobian)
* Compute the solution update `x = grp.x + step * d`.
*/
void
- computeX(const NOX::Abstract::Group & grp,
+ computeX(const NOX::Abstract::Group &grp,
const NOX::Abstract::Vector &d,
double step) override
{
*/
NOX::Abstract::Group::ReturnType
applyJacobian(const NOX::Abstract::Vector &input,
- NOX::Abstract::Vector & result) const override
+ NOX::Abstract::Vector &result) const override
{
if (apply_jacobian == nullptr)
return NOX::Abstract::Group::NotDefined;
*/
const std::function<SolverControl::State(const unsigned int i,
const double f_norm,
- const VectorType & x,
- const VectorType & f)>
+ const VectorType &x,
+ const VectorType &f)>
check_iteration_status;
/**
template <typename VectorType>
NOXSolver<VectorType>::NOXSolver(
- AdditionalData & additional_data,
+ AdditionalData &additional_data,
const Teuchos::RCP<Teuchos::ParameterList> ¶meters)
: additional_data(additional_data)
, parameters(parameters)
&spheres);
template SphereNearestPredicate::SphereNearestPredicate(
const std::vector<std::pair<dealii::Point<DIM, SCALAR>, SCALAR>>
- & spheres,
+ &spheres,
const unsigned int n_nearest_neighbors);
\}
DEAL_II_NAMESPACE_CLOSE
template <int dim>
Tensor<1, dim>
-AutoDerivativeFunction<dim>::gradient(const Point<dim> & p,
+AutoDerivativeFunction<dim>::gradient(const Point<dim> &p,
const unsigned int comp) const
{
Tensor<1, dim> grad;
template <int dim>
void
AutoDerivativeFunction<dim>::vector_gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
std::vector<Tensor<1, dim>> &gradients) const
{
Assert(gradients.size() == this->n_components,
void
AutoDerivativeFunction<dim>::gradient_list(
const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int comp) const
{
Assert(gradients.size() == points.size(),
template <int dim>
void
AutoDerivativeFunction<dim>::vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &gradients) const
{
Assert(gradients.size() == points.size(),
*/
template <typename T>
std::string
- compress_array(const std::vector<T> & data,
+ compress_array(const std::vector<T> &data,
const DataOutBase::CompressionLevel compression_level)
{
#ifdef DEAL_II_WITH_ZLIB
*/
template <typename T>
std::string
- vtu_stringize_array(const std::vector<T> & data,
+ vtu_stringize_array(const std::vector<T> &data,
const DataOutBase::CompressionLevel compression_level,
const int precision)
{
void
- DataOutFilter::write_data_set(const std::string & name,
+ DataOutFilter::write_data_set(const std::string &name,
const unsigned int dimension,
const unsigned int set_num,
const Table<2, double> &data_vectors)
template <int dim, int spacedim>
inline Point<spacedim>
get_equispaced_location(
- const DataOutBase::Patch<dim, spacedim> & patch,
+ const DataOutBase::Patch<dim, spacedim> &patch,
const std::initializer_list<unsigned int> &lattice_location,
const unsigned int n_subdivisions)
{
- TecplotStream::TecplotStream(std::ostream & out,
+ TecplotStream::TecplotStream(std::ostream &out,
const DataOutBase::TecplotFlags &f)
: StreamBase<DataOutBase::TecplotFlags>(out, f)
{}
template <int dim, int spacedim, typename StreamType>
void
write_high_order_cells(const std::vector<Patch<dim, spacedim>> &patches,
- StreamType & out,
+ StreamType &out,
const bool legacy_format)
{
Assert(dim <= 3 && dim > 1, ExcNotImplemented());
write_data(const std::vector<Patch<dim, spacedim>> &patches,
unsigned int n_data_sets,
const bool double_precision,
- StreamType & out)
+ StreamType &out)
{
Assert(dim <= 3, ExcNotImplemented());
unsigned int count = 0;
void
write_ucd(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>> &,
const UcdFlags &flags,
- std::ostream & out)
+ std::ostream &out)
{
// Note that while in theory dim==0 should be implemented, this is not
// tested, therefore currently not allowed.
void
write_dx(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>> &,
const DXFlags &flags,
- std::ostream & out)
+ std::ostream &out)
{
// Point output is currently not implemented.
AssertThrow(dim > 0, ExcNotImplemented());
void
write_gnuplot(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>> &,
const GnuplotFlags &flags,
- std::ostream & out)
+ std::ostream &out)
{
AssertThrow(out.fail() == false, ExcIO());
void
do_write_povray(const std::vector<Patch<2, 2>> &patches,
const std::vector<std::string> &data_names,
- const PovrayFlags & flags,
- std::ostream & out)
+ const PovrayFlags &flags,
+ std::ostream &out)
{
AssertThrow(out.fail() == false, ExcIO());
void
write_povray(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>> &,
const PovrayFlags &flags,
- std::ostream & out)
+ std::ostream &out)
{
do_write_povray(patches, data_names, flags, out);
}
std::string,
DataComponentInterpretation::DataComponentInterpretation>> &,
const EpsFlags &flags,
- std::ostream & out)
+ std::ostream &out)
{
AssertThrow(out.fail() == false, ExcIO());
void
write_gmv(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>> &,
const GmvFlags &flags,
- std::ostream & out)
+ std::ostream &out)
{
// The gmv format does not support cells that only consist of a single
// point. It does support the output of point data using the keyword
void
write_tecplot(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>> &,
const TecplotFlags &flags,
- std::ostream & out)
+ std::ostream &out)
{
AssertThrow(out.fail() == false, ExcIO());
void
write_vtk(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const VtkFlags &flags,
- std::ostream & out)
+ std::ostream &out)
{
AssertThrow(out.fail() == false, ExcIO());
void
write_vtu(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const VtkFlags &flags,
- std::ostream & out)
+ std::ostream &out)
{
write_vtu_header(out, flags);
write_vtu_main(patches, data_names, nonscalar_data_ranges, flags, out);
void
write_vtu_main(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const VtkFlags &flags,
- std::ostream & out)
+ std::ostream &out)
{
AssertThrow(out.fail() == false, ExcIO());
n_data_sets,
n_nodes,
output_precision = out.precision()](const Table<2, float> &data_vectors,
- const auto & range) {
+ const auto &range) {
std::ostringstream o;
const auto first_component = std::get<0>(range);
void
write_pvtu_record(
- std::ostream & out,
+ std::ostream &out,
const std::vector<std::string> &piece_names,
const std::vector<std::string> &data_names,
const std::vector<
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const VtkFlags &flags)
{
AssertThrow(out.fail() == false, ExcIO());
void
write_pvd_record(
- std::ostream & out,
+ std::ostream &out,
const std::vector<std::pair<double, std::string>> ×_and_names)
{
AssertThrow(out.fail() == false, ExcIO());
void
- write_visit_record(std::ostream & out,
+ write_visit_record(std::ostream &out,
const std::vector<std::string> &piece_names)
{
out << "!NBLOCKS " << piece_names.size() << '\n';
void
- write_visit_record(std::ostream & out,
+ write_visit_record(std::ostream &out,
const std::vector<std::vector<std::string>> &piece_names)
{
AssertThrow(out.fail() == false, ExcIO());
DataComponentInterpretation::DataComponentInterpretation>>
& /*nonscalar_data_ranges*/,
const SvgFlags &flags,
- std::ostream & out)
+ std::ostream &out)
{
const unsigned int height = flags.height;
unsigned int width = flags.width;
void
write_deal_II_intermediate(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
void
write_deal_II_intermediate_in_parallel(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const Deal_II_IntermediateFlags &flags,
- const std::string & filename,
+ const std::string &filename,
const MPI_Comm comm,
const CompressionLevel compression)
{
AssertThrowMPI(ierr);
{
- const auto & patches = get_patches();
+ const auto &patches = get_patches();
const types::global_dof_index my_n_patches = patches.size();
const types::global_dof_index global_n_patches =
Utilities::MPI::sum(my_n_patches, comm);
template <int dim, int spacedim>
void
DataOutInterface<dim, spacedim>::write_pvtu_record(
- std::ostream & out,
+ std::ostream &out,
const std::vector<std::string> &piece_names) const
{
DataOutBase::write_pvtu_record(out,
template <int dim, int spacedim>
void
DataOutInterface<dim, spacedim>::write_deal_II_intermediate_in_parallel(
- const std::string & filename,
+ const std::string &filename,
const MPI_Comm comm,
const DataOutBase::CompressionLevel compression) const
{
XDMFEntry
DataOutInterface<dim, spacedim>::create_xdmf_entry(
const DataOutBase::DataOutFilter &data_filter,
- const std::string & h5_filename,
+ const std::string &h5_filename,
const double cur_time,
const MPI_Comm comm) const
{
XDMFEntry
DataOutInterface<dim, spacedim>::create_xdmf_entry(
const DataOutBase::DataOutFilter &data_filter,
- const std::string & h5_mesh_filename,
- const std::string & h5_solution_filename,
+ const std::string &h5_mesh_filename,
+ const std::string &h5_solution_filename,
const double cur_time,
const MPI_Comm comm) const
{
void
DataOutInterface<dim, spacedim>::write_xdmf_file(
const std::vector<XDMFEntry> &entries,
- const std::string & filename,
+ const std::string &filename,
const MPI_Comm comm) const
{
#ifdef DEAL_II_WITH_MPI
void
do_write_hdf5(const std::vector<DataOutBase::Patch<dim, spacedim>> &patches,
const DataOutBase::DataOutFilter &data_filter,
- const DataOutBase::Hdf5Flags & flags,
+ const DataOutBase::Hdf5Flags &flags,
const bool write_mesh_file,
- const std::string & mesh_filename,
- const std::string & solution_filename,
+ const std::string &mesh_filename,
+ const std::string &solution_filename,
const MPI_Comm comm)
{
hid_t h5_mesh_file_id = -1, h5_solution_file_id, file_plist_id, plist_id;
void
DataOutBase::write_filtered_data(
const std::vector<Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & data_names,
+ const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
DataOutBase::DataOutFilter &filtered_data)
{
const unsigned int n_data_sets = data_names.size();
void
DataOutInterface<dim, spacedim>::write_hdf5_parallel(
const DataOutBase::DataOutFilter &data_filter,
- const std::string & filename,
+ const std::string &filename,
const MPI_Comm comm) const
{
DataOutBase::write_hdf5_parallel(
DataOutInterface<dim, spacedim>::write_hdf5_parallel(
const DataOutBase::DataOutFilter &data_filter,
const bool write_mesh_file,
- const std::string & mesh_filename,
- const std::string & solution_filename,
+ const std::string &mesh_filename,
+ const std::string &solution_filename,
const MPI_Comm comm) const
{
DataOutBase::write_hdf5_parallel(get_patches(),
void
DataOutBase::write_hdf5_parallel(
const std::vector<Patch<dim, spacedim>> &patches,
- const DataOutBase::DataOutFilter & data_filter,
- const DataOutBase::Hdf5Flags & flags,
- const std::string & filename,
+ const DataOutBase::DataOutFilter &data_filter,
+ const DataOutBase::Hdf5Flags &flags,
+ const std::string &filename,
const MPI_Comm comm)
{
write_hdf5_parallel(
void
DataOutBase::write_hdf5_parallel(
const std::vector<Patch<dim, spacedim>> &patches,
- const DataOutBase::DataOutFilter & data_filter,
- const DataOutBase::Hdf5Flags & flags,
+ const DataOutBase::DataOutFilter &data_filter,
+ const DataOutBase::Hdf5Flags &flags,
const bool write_mesh_file,
- const std::string & mesh_filename,
- const std::string & solution_filename,
+ const std::string &mesh_filename,
+ const std::string &solution_filename,
const MPI_Comm comm)
{
AssertThrow(
template <int dim, int spacedim>
void
DataOutInterface<dim, spacedim>::write(
- std::ostream & out,
+ std::ostream &out,
const DataOutBase::OutputFormat output_format_) const
{
DataOutBase::OutputFormat output_format = output_format_;
-XDMFEntry::XDMFEntry(const std::string & filename,
+XDMFEntry::XDMFEntry(const std::string &filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
: XDMFEntry(filename, filename, time, nodes, cells, dim, dim, ReferenceCell())
{}
-XDMFEntry::XDMFEntry(const std::string & filename,
+XDMFEntry::XDMFEntry(const std::string &filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
-XDMFEntry::XDMFEntry(const std::string & mesh_filename,
- const std::string & solution_filename,
+XDMFEntry::XDMFEntry(const std::string &mesh_filename,
+ const std::string &solution_filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
-XDMFEntry::XDMFEntry(const std::string & mesh_filename,
- const std::string & solution_filename,
+XDMFEntry::XDMFEntry(const std::string &mesh_filename,
+ const std::string &solution_filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
-XDMFEntry::XDMFEntry(const std::string & mesh_filename,
- const std::string & solution_filename,
+XDMFEntry::XDMFEntry(const std::string &mesh_filename,
+ const std::string &solution_filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
-XDMFEntry::XDMFEntry(const std::string & mesh_filename,
- const std::string & solution_filename,
+XDMFEntry::XDMFEntry(const std::string &mesh_filename,
+ const std::string &solution_filename,
const double time,
const std::uint64_t nodes,
const std::uint64_t cells,
template std::ostream &
operator<<(
- std::ostream & out,
+ std::ostream &out,
const Patch<deal_II_dimension, deal_II_space_dimension> &patch);
template std::istream &
- operator>>(std::istream & in,
+ operator>>(std::istream &in,
Patch<deal_II_dimension, deal_II_space_dimension> &patch);
template void
write_vtk(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const VtkFlags &flags,
- std::ostream & out);
+ std::ostream &out);
template void
write_vtu(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const VtkFlags &flags,
- std::ostream & out);
+ std::ostream &out);
template void
write_ucd(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const UcdFlags &flags,
- std::ostream & out);
+ std::ostream &out);
template void
write_dx(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const DXFlags &flags,
- std::ostream & out);
+ std::ostream &out);
template void
write_gnuplot(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const GnuplotFlags &flags,
- std::ostream & out);
+ std::ostream &out);
template void
write_povray(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const PovrayFlags &flags,
- std::ostream & out);
+ std::ostream &out);
template void
write_eps(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const EpsFlags &flags,
- std::ostream & out);
+ std::ostream &out);
template void
write_gmv(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const GmvFlags &flags,
- std::ostream & out);
+ std::ostream &out);
template void
write_tecplot(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const TecplotFlags &flags,
- std::ostream & out);
+ std::ostream &out);
# if deal_II_space_dimension > 1
template void
write_svg(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const SvgFlags &flags,
- std::ostream & out);
+ std::ostream &out);
# endif
template void
write_deal_II_intermediate(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const Deal_II_IntermediateFlags &flags,
- std::ostream & out);
+ std::ostream &out);
template void
write_deal_II_intermediate_in_parallel(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
+ &patches,
const std::vector<std::string> &data_names,
const std::vector<
std::tuple<unsigned int,
unsigned int,
std::string,
DataComponentInterpretation::DataComponentInterpretation>>
- & nonscalar_data_ranges,
+ &nonscalar_data_ranges,
const Deal_II_IntermediateFlags &flags,
- const std::string & filename,
+ const std::string &filename,
const MPI_Comm comm,
const CompressionLevel compression);
template void
write_hdf5_parallel(
const std::vector<Patch<deal_II_dimension, deal_II_space_dimension>>
- & patches,
- const DataOutFilter & data_filter,
+ &patches,
+ const DataOutFilter &data_filter,
const DataOutBase::Hdf5Flags &flags,
- const std::string & filename,
+ const std::string &filename,
const MPI_Comm comm);
template void
void
FlowFunction<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
const unsigned int n_points = points.size();
Assert(values.size() == n_points,
template <int dim>
void
FlowFunction<dim>::vector_value(const Point<dim> &point,
- Vector<double> & value) const
+ Vector<double> &value) const
{
Assert(value.size() == dim + 1,
ExcDimensionMismatch(value.size(), dim + 1));
template <int dim>
double
- FlowFunction<dim>::value(const Point<dim> & point,
+ FlowFunction<dim>::value(const Point<dim> &point,
const unsigned int comp) const
{
AssertIndexRange(comp, dim + 1);
template <int dim>
void
FlowFunction<dim>::vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &values) const
{
const unsigned int n_points = points.size();
void
FlowFunction<dim>::vector_laplacian_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
const unsigned int n_points = points.size();
Assert(values.size() == n_points,
template <int dim>
void
PoisseuilleFlow<dim>::vector_values(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<double>> &values) const
{
const unsigned int n = points.size();
template <int dim>
void
PoisseuilleFlow<dim>::vector_gradients(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &values) const
{
const unsigned int n = points.size();
template <int dim>
void
PoisseuilleFlow<dim>::vector_laplacians(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<double>> &values) const
{
const unsigned int n = points.size();
template <int dim>
void
StokesCosine<dim>::vector_values(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<double>> &values) const
{
unsigned int n = points.size();
template <int dim>
void
StokesCosine<dim>::vector_gradients(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &values) const
{
unsigned int n = points.size();
template <int dim>
void
StokesCosine<dim>::vector_laplacians(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<double>> &values) const
{
unsigned int n = points.size();
void
StokesLSingularity::vector_values(
- const std::vector<Point<2>> & points,
+ const std::vector<Point<2>> &points,
std::vector<std::vector<double>> &values) const
{
unsigned int n = points.size();
void
StokesLSingularity::vector_gradients(
- const std::vector<Point<2>> & points,
+ const std::vector<Point<2>> &points,
std::vector<std::vector<Tensor<1, 2>>> &values) const
{
unsigned int n = points.size();
void
StokesLSingularity::vector_laplacians(
- const std::vector<Point<2>> & points,
+ const std::vector<Point<2>> &points,
std::vector<std::vector<double>> &values) const
{
unsigned int n = points.size();
void
- Kovasznay::vector_values(const std::vector<Point<2>> & points,
+ Kovasznay::vector_values(const std::vector<Point<2>> &points,
std::vector<std::vector<double>> &values) const
{
unsigned int n = points.size();
void
Kovasznay::vector_gradients(
- const std::vector<Point<2>> & points,
+ const std::vector<Point<2>> &points,
std::vector<std::vector<Tensor<1, 2>>> &gradients) const
{
unsigned int n = points.size();
void
- Kovasznay::vector_laplacians(const std::vector<Point<2>> & points,
+ Kovasznay::vector_laplacians(const std::vector<Point<2>> &points,
std::vector<std::vector<double>> &values) const
{
unsigned int n = points.size();
template <int dim>
FunctionDerivative<dim>::FunctionDerivative(const Function<dim> &f,
- const Point<dim> & dir,
+ const Point<dim> &dir,
const double h)
: AutoDerivativeFunction<dim>(h, f.n_components, f.get_time())
, f(f)
template <int dim>
-FunctionDerivative<dim>::FunctionDerivative(const Function<dim> & f,
+FunctionDerivative<dim>::FunctionDerivative(const Function<dim> &f,
const std::vector<Point<dim>> &dir,
const double h)
: AutoDerivativeFunction<dim>(h, f.n_components, f.get_time())
template <int dim>
double
-FunctionDerivative<dim>::value(const Point<dim> & p,
+FunctionDerivative<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(incr.size() == 1,
template <int dim>
void
FunctionDerivative<dim>::vector_value(const Point<dim> &p,
- Vector<double> & result) const
+ Vector<double> &result) const
{
Assert(incr.size() == 1,
ExcMessage(
template <int dim>
void
FunctionDerivative<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n = points.size();
template <int dim>
void
SquareFunction<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
AssertDimension(values.size(), 1);
values(0) = p.square();
template <int dim>
void
SquareFunction<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
template <int dim>
void
SquareFunction<dim>::laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
template <int dim>
void
SquareFunction<dim>::vector_gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
std::vector<Tensor<1, dim>> &values) const
{
AssertDimension(values.size(), 1);
template <int dim>
void
SquareFunction<dim>::gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int) const
{
Assert(gradients.size() == points.size(),
template <int dim>
void
Q1WedgeFunction<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(dim >= 2, ExcInternalError());
void
Q1WedgeFunction<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(dim >= 2, ExcInternalError());
Assert(values.size() == points.size(),
template <int dim>
void
Q1WedgeFunction<dim>::laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(dim >= 2, ExcInternalError());
template <int dim>
void
Q1WedgeFunction<dim>::gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int) const
{
Assert(dim >= 2, ExcInternalError());
template <int dim>
void
Q1WedgeFunction<dim>::vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &gradients) const
{
Assert(dim >= 2, ExcInternalError());
template <int dim>
void
PillowFunction<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
template <int dim>
void
PillowFunction<dim>::laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
template <int dim>
void
PillowFunction<dim>::gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int) const
{
Assert(gradients.size() == points.size(),
template <int dim>
void
CosineFunction<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
void
CosineFunction<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template <int dim>
void
CosineFunction<dim>::laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
template <int dim>
void
CosineFunction<dim>::gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int) const
{
Assert(gradients.size() == points.size(),
template <int dim>
void
CosineFunction<dim>::hessian_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<SymmetricTensor<2, dim>> &hessians,
const unsigned int) const
{
template <int dim>
double
- CosineGradFunction<dim>::value(const Point<dim> & p,
+ CosineGradFunction<dim>::value(const Point<dim> &p,
const unsigned int d) const
{
AssertIndexRange(d, dim);
template <int dim>
void
CosineGradFunction<dim>::vector_value(const Point<dim> &p,
- Vector<double> & result) const
+ Vector<double> &result) const
{
AssertDimension(result.size(), dim);
switch (dim)
template <int dim>
void
CosineGradFunction<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int d) const
{
Assert(values.size() == points.size(),
void
CosineGradFunction<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template <int dim>
double
- CosineGradFunction<dim>::laplacian(const Point<dim> & p,
+ CosineGradFunction<dim>::laplacian(const Point<dim> &p,
const unsigned int d) const
{
return -numbers::PI_2 * numbers::PI_2 * value(p, d);
template <int dim>
Tensor<1, dim>
- CosineGradFunction<dim>::gradient(const Point<dim> & p,
+ CosineGradFunction<dim>::gradient(const Point<dim> &p,
const unsigned int d) const
{
AssertIndexRange(d, dim);
for (unsigned int i = 0; i < points.size(); ++i)
{
const Point<dim> &p = points[i];
- Tensor<1, dim> & result = gradients[i];
+ Tensor<1, dim> &result = gradients[i];
switch (dim)
{
template <int dim>
void
CosineGradFunction<dim>::vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &gradients) const
{
AssertVectorVectorDimension(gradients, points.size(), dim);
template <int dim>
void
ExpFunction<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
template <int dim>
void
ExpFunction<dim>::laplacian_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
template <int dim>
void
ExpFunction<dim>::gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int) const
{
Assert(gradients.size() == points.size(),
void
LSingularityFunction::value_list(const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
void
LSingularityFunction::laplacian_list(const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
void
LSingularityFunction::gradient_list(const std::vector<Point<2>> &points,
- std::vector<Tensor<1, 2>> & gradients,
+ std::vector<Tensor<1, 2>> &gradients,
const unsigned int) const
{
Assert(gradients.size() == points.size(),
void
LSingularityFunction::vector_gradient_list(
- const std::vector<Point<2>> & points,
+ const std::vector<Point<2>> &points,
std::vector<std::vector<Tensor<1, 2>>> &gradients) const
{
Assert(gradients.size() == points.size(),
void
LSingularityGradFunction::value_list(const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int d) const
{
AssertIndexRange(d, 2);
void
LSingularityGradFunction::laplacian_list(const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
void
SlitSingularityFunction<dim>::value_list(
const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
void
SlitSingularityFunction<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
void
SlitSingularityFunction<dim>::laplacian_list(
const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
void
SlitSingularityFunction<dim>::gradient_list(
const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int) const
{
Assert(gradients.size() == points.size(),
template <int dim>
void
SlitSingularityFunction<dim>::vector_gradient_list(
- const std::vector<Point<dim>> & points,
+ const std::vector<Point<dim>> &points,
std::vector<std::vector<Tensor<1, dim>>> &gradients) const
{
Assert(gradients.size() == points.size(),
void
SlitHyperSingularityFunction::value_list(const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
void
SlitHyperSingularityFunction::laplacian_list(
const std::vector<Point<2>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
void
SlitHyperSingularityFunction::gradient_list(
const std::vector<Point<2>> &points,
- std::vector<Tensor<1, 2>> & gradients,
+ std::vector<Tensor<1, 2>> &gradients,
const unsigned int) const
{
Assert(gradients.size() == points.size(),
void
SlitHyperSingularityFunction::vector_gradient_list(
- const std::vector<Point<2>> & points,
+ const std::vector<Point<2>> &points,
std::vector<std::vector<Tensor<1, 2>>> &gradients) const
{
Assert(gradients.size() == points.size(),
template <int dim>
void
JumpFunction<dim>::value_list(const std::vector<Point<dim>> &p,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == p.size(),
template <int dim>
void
JumpFunction<dim>::laplacian_list(const std::vector<Point<dim>> &p,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == p.size(),
template <int dim>
void
JumpFunction<dim>::gradient_list(const std::vector<Point<dim>> &p,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int) const
{
Assert(gradients.size() == p.size(),
template <int dim>
double
- FourierCosineFunction<dim>::value(const Point<dim> & p,
+ FourierCosineFunction<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
Tensor<1, dim>
- FourierCosineFunction<dim>::gradient(const Point<dim> & p,
+ FourierCosineFunction<dim>::gradient(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
double
- FourierCosineFunction<dim>::laplacian(const Point<dim> & p,
+ FourierCosineFunction<dim>::laplacian(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
double
- FourierSineFunction<dim>::value(const Point<dim> & p,
+ FourierSineFunction<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
Tensor<1, dim>
- FourierSineFunction<dim>::gradient(const Point<dim> & p,
+ FourierSineFunction<dim>::gradient(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
double
- FourierSineFunction<dim>::laplacian(const Point<dim> & p,
+ FourierSineFunction<dim>::laplacian(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
FourierSineSum<dim>::FourierSineSum(
const std::vector<Point<dim>> &fourier_coefficients,
- const std::vector<double> & weights)
+ const std::vector<double> &weights)
: Function<dim>(1)
, fourier_coefficients(fourier_coefficients)
, weights(weights)
template <int dim>
double
- FourierSineSum<dim>::value(const Point<dim> & p,
+ FourierSineSum<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
Tensor<1, dim>
- FourierSineSum<dim>::gradient(const Point<dim> & p,
+ FourierSineSum<dim>::gradient(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
double
- FourierSineSum<dim>::laplacian(const Point<dim> & p,
+ FourierSineSum<dim>::laplacian(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
FourierCosineSum<dim>::FourierCosineSum(
const std::vector<Point<dim>> &fourier_coefficients,
- const std::vector<double> & weights)
+ const std::vector<double> &weights)
: Function<dim>(1)
, fourier_coefficients(fourier_coefficients)
, weights(weights)
template <int dim>
double
- FourierCosineSum<dim>::value(const Point<dim> & p,
+ FourierCosineSum<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
Tensor<1, dim>
- FourierCosineSum<dim>::gradient(const Point<dim> & p,
+ FourierCosineSum<dim>::gradient(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
double
- FourierCosineSum<dim>::laplacian(const Point<dim> & p,
+ FourierCosineSum<dim>::laplacian(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim, typename Number>
Number
- Monomial<dim, Number>::value(const Point<dim> & p,
+ Monomial<dim, Number>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim, typename Number>
void
Monomial<dim, Number>::vector_value(const Point<dim> &p,
- Vector<Number> & values) const
+ Vector<Number> &values) const
{
Assert(values.size() == this->n_components,
ExcDimensionMismatch(values.size(), this->n_components));
template <int dim, typename Number>
Tensor<1, dim, Number>
- Monomial<dim, Number>::gradient(const Point<dim> & p,
+ Monomial<dim, Number>::gradient(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim, typename Number>
void
Monomial<dim, Number>::value_list(const std::vector<Point<dim>> &points,
- std::vector<Number> & values,
+ std::vector<Number> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
template <int dim>
void
Bessel1<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(dim == 2, ExcNotImplemented());
template <int dim>
void
Bessel1<dim>::gradient_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & gradients,
+ std::vector<Tensor<1, dim>> &gradients,
const unsigned int) const
{
Assert(dim == 2, ExcNotImplemented());
// in, and p_unit denotes the point in unit coordinates to do so.
double
interpolate(const Table<1, double> &data_values,
- const TableIndices<1> & ix,
- const Point<1> & xi)
+ const TableIndices<1> &ix,
+ const Point<1> &xi)
{
return ((1 - xi[0]) * data_values[ix[0]] +
xi[0] * data_values[ix[0] + 1]);
double
interpolate(const Table<2, double> &data_values,
- const TableIndices<2> & ix,
- const Point<2> & p_unit)
+ const TableIndices<2> &ix,
+ const Point<2> &p_unit)
{
return (((1 - p_unit[0]) * data_values[ix[0]][ix[1]] +
p_unit[0] * data_values[ix[0] + 1][ix[1]]) *
double
interpolate(const Table<3, double> &data_values,
- const TableIndices<3> & ix,
- const Point<3> & p_unit)
+ const TableIndices<3> &ix,
+ const Point<3> &p_unit)
{
return ((((1 - p_unit[0]) * data_values[ix[0]][ix[1]][ix[2]] +
p_unit[0] * data_values[ix[0] + 1][ix[1]][ix[2]]) *
// denotes the width of the interval in each dimension.
Tensor<1, 1>
gradient_interpolate(const Table<1, double> &data_values,
- const TableIndices<1> & ix,
- const Point<1> & p_unit,
- const Point<1> & dx)
+ const TableIndices<1> &ix,
+ const Point<1> &p_unit,
+ const Point<1> &dx)
{
(void)p_unit;
Tensor<1, 1> grad;
Tensor<1, 2>
gradient_interpolate(const Table<2, double> &data_values,
- const TableIndices<2> & ix,
- const Point<2> & p_unit,
- const Point<2> & dx)
+ const TableIndices<2> &ix,
+ const Point<2> &p_unit,
+ const Point<2> &dx)
{
Tensor<1, 2> grad;
double u00 = data_values[ix[0]][ix[1]],
Tensor<1, 3>
gradient_interpolate(const Table<3, double> &data_values,
- const TableIndices<3> & ix,
- const Point<3> & p_unit,
- const Point<3> & dx)
+ const TableIndices<3> &ix,
+ const Point<3> &p_unit,
+ const Point<3> &dx)
{
Tensor<1, 3> grad;
double u000 = data_values[ix[0]][ix[1]][ix[2]],
template <int dim>
InterpolatedTensorProductGridData<dim>::InterpolatedTensorProductGridData(
const std::array<std::vector<double>, dim> &coordinate_values,
- const Table<dim, double> & data_values)
+ const Table<dim, double> &data_values)
: coordinate_values(coordinate_values)
, data_values(data_values)
{
template <int dim>
InterpolatedTensorProductGridData<dim>::InterpolatedTensorProductGridData(
std::array<std::vector<double>, dim> &&coordinate_values,
- Table<dim, double> && data_values)
+ Table<dim, double> &&data_values)
: coordinate_values(std::move(coordinate_values))
, data_values(std::move(data_values))
{
template <int dim>
double
InterpolatedTensorProductGridData<dim>::value(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
Tensor<1, dim>
InterpolatedTensorProductGridData<dim>::gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
InterpolatedUniformGridData<dim>::InterpolatedUniformGridData(
const std::array<std::pair<double, double>, dim> &interval_endpoints,
- const std::array<unsigned int, dim> & n_subintervals,
- const Table<dim, double> & data_values)
+ const std::array<unsigned int, dim> &n_subintervals,
+ const Table<dim, double> &data_values)
: interval_endpoints(interval_endpoints)
, n_subintervals(n_subintervals)
, data_values(data_values)
template <int dim>
InterpolatedUniformGridData<dim>::InterpolatedUniformGridData(
std::array<std::pair<double, double>, dim> &&interval_endpoints,
- std::array<unsigned int, dim> && n_subintervals,
- Table<dim, double> && data_values)
+ std::array<unsigned int, dim> &&n_subintervals,
+ Table<dim, double> &&data_values)
: interval_endpoints(std::move(interval_endpoints))
, n_subintervals(std::move(n_subintervals))
, data_values(std::move(data_values))
template <int dim>
double
- InterpolatedUniformGridData<dim>::value(const Point<dim> & p,
+ InterpolatedUniformGridData<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
Tensor<1, dim>
- InterpolatedUniformGridData<dim>::gradient(const Point<dim> & p,
+ InterpolatedUniformGridData<dim>::gradient(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
- Polynomial<dim>::Polynomial(const Table<2, double> & exponents,
+ Polynomial<dim>::Polynomial(const Table<2, double> &exponents,
const std::vector<double> &coefficients)
: Function<dim>(1)
, exponents(exponents)
template <int dim>
double
- Polynomial<dim>::value(const Point<dim> & p,
+ Polynomial<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
void
Polynomial<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
template <int dim>
Tensor<1, dim>
- Polynomial<dim>::gradient(const Point<dim> & p,
+ Polynomial<dim>::gradient(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
CutOffFunctionTensorProduct<dim>::CutOffFunctionTensorProduct(
double radius,
- const Point<dim> & center,
+ const Point<dim> ¢er,
const unsigned int n_components,
const unsigned int select,
const bool integrate_to_one)
template <int dim>
double
- CutOffFunctionTensorProduct<dim>::value(const Point<dim> & p,
+ CutOffFunctionTensorProduct<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(initialized, ExcNotInitialized());
template <int dim>
Tensor<1, dim>
- CutOffFunctionTensorProduct<dim>::gradient(const Point<dim> & p,
+ CutOffFunctionTensorProduct<dim>::gradient(const Point<dim> &p,
const unsigned int component) const
{
Assert(initialized, ExcNotInitialized());
template <int dim>
double
- CutOffFunctionLinfty<dim>::value(const Point<dim> & p,
+ CutOffFunctionLinfty<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
if (this->selected == CutOffFunctionBase<dim>::no_component ||
template <int dim>
void
CutOffFunctionLinfty<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
void
CutOffFunctionLinfty<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template <int dim>
double
- CutOffFunctionW1<dim>::value(const Point<dim> & p,
+ CutOffFunctionW1<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
if (this->selected == CutOffFunctionBase<dim>::no_component ||
template <int dim>
void
CutOffFunctionW1<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
void
CutOffFunctionW1<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template <int dim>
double
- CutOffFunctionCinfty<dim>::value(const Point<dim> & p,
+ CutOffFunctionCinfty<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
if (this->selected == CutOffFunctionBase<dim>::no_component ||
template <int dim>
void
CutOffFunctionCinfty<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
void
CutOffFunctionCinfty<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template <int dim>
double
- CutOffFunctionC1<dim>::value(const Point<dim> & p,
+ CutOffFunctionC1<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
if (this->selected == CutOffFunctionBase<dim>::no_component ||
template <int dim>
void
CutOffFunctionC1<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
void
CutOffFunctionC1<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template <int dim>
void
-FunctionParser<dim>::initialize(const std::string & variables,
+FunctionParser<dim>::initialize(const std::string &variables,
const std::vector<std::string> &expressions,
const std::map<std::string, double> &constants,
const bool time_dependent)
template <int dim>
void
-FunctionParser<dim>::initialize(const std::string & vars,
- const std::string & expression,
+FunctionParser<dim>::initialize(const std::string &vars,
+ const std::string &expression,
const std::map<std::string, double> &constants,
const bool time_dependent)
{
template <int dim>
double
-FunctionParser<dim>::value(const Point<dim> & p,
+FunctionParser<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
return this->do_value(p, this->get_time(), component);
{
template <int dim>
Point<dim + 1>
- create_higher_dim_point(const Point<dim> & point,
+ create_higher_dim_point(const Point<dim> &point,
const unsigned int component_in_dim_plus_1,
const double coordinate_value)
{
template <int dim>
double
- CoordinateRestriction<dim>::value(const Point<dim> & point,
+ CoordinateRestriction<dim>::value(const Point<dim> &point,
const unsigned int component) const
{
const Point<dim + 1> full_point =
template <int dim>
Tensor<1, dim>
- CoordinateRestriction<dim>::gradient(const Point<dim> & point,
+ CoordinateRestriction<dim>::gradient(const Point<dim> &point,
const unsigned int component) const
{
const Point<dim + 1> full_point =
template <int dim>
SymmetricTensor<2, dim>
- CoordinateRestriction<dim>::hessian(const Point<dim> & point,
+ CoordinateRestriction<dim>::hessian(const Point<dim> &point,
const unsigned int component) const
{
const Point<dim + 1> full_point =
template <int dim>
PointRestriction<dim>::PointRestriction(const Function<dim + 1> &function,
const unsigned int open_direction,
- const Point<dim> & point)
+ const Point<dim> &point)
: function(&function)
, open_direction(open_direction)
, point(point)
template <int dim>
double
- PointRestriction<dim>::value(const Point<1> & point_1D,
+ PointRestriction<dim>::value(const Point<1> &point_1D,
const unsigned int component) const
{
const Point<dim + 1> full_point =
template <int dim>
Tensor<1, 1>
- PointRestriction<dim>::gradient(const Point<1> & point_1D,
+ PointRestriction<dim>::gradient(const Point<1> &point_1D,
const unsigned int component) const
{
const Point<dim + 1> full_point =
template <int dim>
SymmetricTensor<2, 1>
- PointRestriction<dim>::hessian(const Point<1> & point_1D,
+ PointRestriction<dim>::hessian(const Point<1> &point_1D,
const unsigned int component) const
{
const Point<dim + 1> full_point =
template <int dim>
double
- Sphere<dim>::value(const Point<dim> & point,
+ Sphere<dim>::value(const Point<dim> &point,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim>
Tensor<1, dim>
- Sphere<dim>::gradient(const Point<dim> & point,
+ Sphere<dim>::gradient(const Point<dim> &point,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim>
SymmetricTensor<2, dim>
- Sphere<dim>::hessian(const Point<dim> & point,
+ Sphere<dim>::hessian(const Point<dim> &point,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim>
double
- Plane<dim>::value(const Point<dim> & point,
+ Plane<dim>::value(const Point<dim> &point,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim>
- Ellipsoid<dim>::Ellipsoid(const Point<dim> & center,
+ Ellipsoid<dim>::Ellipsoid(const Point<dim> ¢er,
const std::array<double, dim> &radii,
const double tolerance,
const unsigned int max_iter)
template <int dim>
double
- Ellipsoid<dim>::value(const Point<dim> & point,
+ Ellipsoid<dim>::value(const Point<dim> &point,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim>
Tensor<1, dim>
- Ellipsoid<dim>::gradient(const Point<dim> & point,
+ Ellipsoid<dim>::gradient(const Point<dim> &point,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim>
double
- Rectangle<dim>::value(const Point<dim> & p,
+ Rectangle<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
AssertDimension(component, 0);
template <int dim>
double
- ZalesakDisk<dim>::value(const Point<dim> & p,
+ ZalesakDisk<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
void
add_outer_product(SymmetricTensor<2, dim> &out,
const double val,
- const Tensor<1, dim> & in1,
- const Tensor<1, dim> & in2)
+ const Tensor<1, dim> &in1,
+ const Tensor<1, dim> &in2)
{
if (val != 0.)
for (unsigned int i = 0; i < dim; ++i)
void
add_outer_product(SymmetricTensor<2, dim> &out,
const double val,
- const Tensor<1, dim> & in)
+ const Tensor<1, dim> &in)
{
if (val != 0.)
for (unsigned int i = 0; i < dim; ++i)
template <int dim>
- Spherical<dim>::Spherical(const Point<dim> & p,
+ Spherical<dim>::Spherical(const Point<dim> &p,
const unsigned int n_components)
: Function<dim>(n_components)
, coordinate_system_offset(p)
template <int dim>
double
- Spherical<dim>::value(const Point<dim> & p_,
+ Spherical<dim>::value(const Point<dim> &p_,
const unsigned int component) const
{
const Point<dim> p = p_ - coordinate_system_offset;
template <int dim>
void
taylor_estimate_function_bounds(
- const Function<dim> & function,
- const BoundingBox<dim> & box,
- std::pair<double, double> & value_bounds,
+ const Function<dim> &function,
+ const BoundingBox<dim> &box,
+ std::pair<double, double> &value_bounds,
std::array<std::pair<double, double>, dim> &gradient_bounds,
const unsigned int component)
{
namespace GraphColoring
{
unsigned int
- color_sparsity_pattern(const SparsityPattern & sparsity_pattern,
+ color_sparsity_pattern(const SparsityPattern &sparsity_pattern,
std::vector<unsigned int> &color_indices)
{
return SparsityTools::color_sparsity_pattern(sparsity_pattern,
DataSet::DataSet(const std::string &name,
- const hid_t & parent_group_id,
+ const hid_t &parent_group_id,
const bool mpi)
: HDF5Object(name, mpi)
, query_io_mode(false)
- DataSet::DataSet(const std::string & name,
- const hid_t & parent_group_id,
- const std::vector<hsize_t> & dimensions,
+ DataSet::DataSet(const std::string &name,
+ const hid_t &parent_group_id,
+ const std::vector<hsize_t> &dimensions,
const std::shared_ptr<hid_t> &t_type,
const bool mpi)
: HDF5Object(name, mpi)
- Group::Group(const std::string & name,
- const Group & parentGroup,
+ Group::Group(const std::string &name,
+ const Group &parentGroup,
const bool mpi,
const GroupAccessMode mode)
: HDF5Object(name, mpi)
- File::File(const std::string & name,
+ File::File(const std::string &name,
const FileAccessMode mode,
const MPI_Comm mpi_communicator)
: File(name, mode, true, mpi_communicator)
- File::File(const std::string & name,
+ File::File(const std::string &name,
const FileAccessMode mode,
const bool mpi,
const MPI_Comm mpi_communicator)
template <int dim, typename RangeNumberType>
RangeNumberType
IncrementalFunction<dim, RangeNumberType>::value(
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int comp) const
{
// since we modify a mutable member variable, lock the
template <int dim, typename RangeNumberType>
void
IncrementalFunction<dim, RangeNumberType>::vector_value(
- const Point<dim> & p,
+ const Point<dim> &p,
Vector<RangeNumberType> &values) const
{
// since we modify a mutable member variable, lock the
else
{
const size_type n_indices = map.NumMyElements();
- size_type * indices =
+ size_type *indices =
reinterpret_cast<size_type *>(map.MyGlobalElements64());
add_indices(indices, indices + n_indices);
}
else
{
const size_type n_indices = map.NumMyElements();
- unsigned int * indices =
+ unsigned int *indices =
reinterpret_cast<unsigned int *>(map.MyGlobalElements());
add_indices(indices, indices + n_indices);
}
void
IndexSet::add_ranges_internal(
boost::container::small_vector<std::pair<size_type, size_type>, 200>
- & tmp_ranges,
+ &tmp_ranges,
const bool ranges_are_sorted)
{
if (!ranges_are_sorted)
void
-LogStream::attach(std::ostream & o,
+LogStream::attach(std::ostream &o,
const bool print_job_id,
const std::ios_base::fmtflags flags)
{
void
LogStream::print_line_head()
{
- const std::string & head = get_prefix();
+ const std::string &head = get_prefix();
const std::thread::id thread = std::this_thread::get_id();
if (get_prefixes().size() <= std_depth)
create_group(const MPI_Comm comm,
const MPI_Group &group,
const int tag,
- MPI_Comm * new_comm)
+ MPI_Comm *new_comm)
{
const int ierr = MPI_Comm_create_group(comm, group, tag, new_comm);
AssertThrowMPI(ierr);
// custom MIP_Op for calculate_collective_mpi_min_max_avg
void
max_reduce(const void *in_lhs_,
- void * inout_rhs_,
- int * len,
+ void *inout_rhs_,
+ int *len,
MPI_Datatype *)
{
const MinMaxAvg *in_lhs = static_cast<const MinMaxAvg *>(in_lhs_);
- MinMaxAvg * inout_rhs = static_cast<MinMaxAvg *>(inout_rhs_);
+ MinMaxAvg *inout_rhs = static_cast<MinMaxAvg *>(inout_rhs_);
for (int i = 0; i < *len; ++i)
{
void
min_max_avg(const ArrayView<const double> &my_values,
- const ArrayView<MinMaxAvg> & result,
+ const ArrayView<MinMaxAvg> &result,
const MPI_Comm mpi_communicator)
{
// If MPI was not started, we have a serial computation and cannot run
- void free_communicator(MPI_Comm /*mpi_communicator*/)
+ void
+ free_communicator(MPI_Comm /*mpi_communicator*/)
{}
void
min_max_avg(const ArrayView<const double> &my_values,
- const ArrayView<MinMaxAvg> & result,
+ const ArrayView<MinMaxAvg> &result,
const MPI_Comm)
{
AssertDimension(my_values.size(), result.size());
MPI_InitFinalize::Signals();
- MPI_InitFinalize::MPI_InitFinalize(int & argc,
- char **& argv,
+ MPI_InitFinalize::MPI_InitFinalize(int &argc,
+ char **&argv,
const unsigned int max_num_threads)
{
static bool constructor_has_already_run = false;
const MPI_Comm,
const ArrayView<S> &);
- template S reduce(const S & vec,
+ template S reduce(const S &vec,
const MPI_Comm comm,
const std::function<S(const S &, const S &)> &process,
const unsigned int root_process);
template std::vector<S> reduce(
- const std::vector<S> & vec,
+ const std::vector<S> &vec,
const MPI_Comm comm,
const std::function<std::vector<S>(const std::vector<S> &,
const std::vector<S> &)> &process,
const unsigned int root_process);
template S all_reduce(
- const S & vec,
+ const S &vec,
const MPI_Comm comm,
const std::function<S(const S &, const S &)> &process);
template std::vector<S> all_reduce(
- const std::vector<S> & vec,
+ const std::vector<S> &vec,
const MPI_Comm comm,
const std::function<std::vector<S>(const std::vector<S> &,
const std::vector<S> &)> &process);
ConsensusAlgorithmsPayload::ConsensusAlgorithmsPayload(
- const IndexSet & owned_indices,
- const IndexSet & indices_to_look_up,
+ const IndexSet &owned_indices,
+ const IndexSet &indices_to_look_up,
const MPI_Comm comm,
std::vector<unsigned int> &owning_ranks,
const bool track_index_requests)
const unsigned int other_rank,
const std::vector<std::pair<types::global_dof_index,
types::global_dof_index>> &buffer_recv,
- std::vector<unsigned int> & request_buffer)
+ std::vector<unsigned int> &request_buffer)
{
unsigned int owner_index_guess = 0;
for (const auto &interval : buffer_recv)
const unsigned int index_within_dict,
const unsigned int rank_of_request,
const unsigned int rank_of_owner,
- unsigned int & owner_index_guess)
+ unsigned int &owner_index_guess)
{
// remember who requested which index. We want to use an
// std::vector with simple addressing, via a good guess from the
template void
NoncontiguousPartitioner::export_to_ghosted_array(
const ArrayView<const S> &src,
- const ArrayView<S> & dst) const;
+ const ArrayView<S> &dst) const;
template void
NoncontiguousPartitioner::import_from_ghosted_array(
const VectorOperation::values vector_operation,
- const ArrayView<S> & src,
- const ArrayView<S> & dst) const;
+ const ArrayView<S> &src,
+ const ArrayView<S> &dst) const;
\}
\}
}
RemotePointEvaluation<dim, spacedim>::reinit(
const std::vector<Point<spacedim>> &points,
const Triangulation<dim, spacedim> &tria,
- const Mapping<dim, spacedim> & mapping)
+ const Mapping<dim, spacedim> &mapping)
{
#ifndef DEAL_II_WITH_MPI
Assert(false, ExcNeedsMPI());
RemotePointEvaluation<dim, spacedim>::reinit(
const GridTools::internal::
DistributedComputePointLocationsInternal<dim, spacedim> &data,
- const Triangulation<dim, spacedim> & tria,
- const Mapping<dim, spacedim> & mapping)
+ const Triangulation<dim, spacedim> &tria,
+ const Mapping<dim, spacedim> &mapping)
{
this->tria = &tria;
this->mapping = &mapping;
template <int dim, typename Number>
void
ParserImplementation<dim, Number>::initialize(
- const std::string & variables,
- const std::vector<std::string> & expressions,
+ const std::string &variables,
+ const std::vector<std::string> &expressions,
const std::map<std::string, double> &constants,
const bool time_dependent)
{
template <int dim, typename Number>
void
ParserImplementation<dim, Number>::do_all_values(
- const Point<dim> & p,
+ const Point<dim> &p,
const double time,
ArrayView<Number> &values) const
{
void
ParameterAcceptor::initialize(
- const std::string & filename,
- const std::string & output_filename,
+ const std::string &filename,
+ const std::string &output_filename,
const ParameterHandler::OutputStyle output_style_for_output_filename,
- ParameterHandler & prm,
+ ParameterHandler &prm,
const ParameterHandler::OutputStyle output_style_for_filename)
{
declare_all_parameters(prm);
recursively_sort_parameters(
const char separator,
const std::vector<std::string> &target_subsection_path,
- boost::property_tree::ptree & tree)
+ boost::property_tree::ptree &tree)
{
boost::property_tree::ptree ¤t_section =
tree.get_child(collate_path_string(separator, target_subsection_path));
*/
void
recursively_demangle(const boost::property_tree::ptree &tree_in,
- boost::property_tree::ptree & tree_out,
+ boost::property_tree::ptree &tree_out,
const bool is_parameter_or_alias_node = false)
{
for (const auto &p : tree_in)
std::string
ParameterHandler::get_current_full_path(
const std::vector<std::string> &sub_path,
- const std::string & name) const
+ const std::string &name) const
{
std::string path = get_current_path();
if (path.empty() == false)
void
-ParameterHandler::parse_input(std::istream & input,
+ParameterHandler::parse_input(std::istream &input,
const std::string &filename,
const std::string &last_line,
const bool skip_undefined)
void
read_xml_recursively(
const boost::property_tree::ptree &source,
- const std::string & current_path,
+ const std::string ¤t_path,
const char path_separator,
const std::vector<std::unique_ptr<const Patterns::PatternBase>> &patterns,
const bool skip_undefined,
p.second.put_value<std::string>(temp);
}
else if (p.second.get_optional<std::string>("alias"))
- {}
+ {
+ }
else
{
// it must be a subsection
void
-ParameterHandler::declare_entry(const std::string & entry,
- const std::string & default_value,
+ParameterHandler::declare_entry(const std::string &entry,
+ const std::string &default_value,
const Patterns::PatternBase &pattern,
- const std::string & documentation,
+ const std::string &documentation,
const bool has_to_be_set)
{
entries->put(get_current_full_path(entry) + path_separator + "value",
void
ParameterHandler::add_action(
- const std::string & entry,
+ const std::string &entry,
const std::function<void(const std::string &)> &action,
const bool execute_action)
{
std::string
ParameterHandler::get(const std::vector<std::string> &entry_subsection_path,
- const std::string & entry_string) const
+ const std::string &entry_string) const
{
// assert that the entry is indeed
// declared
long int
ParameterHandler::get_integer(
const std::vector<std::string> &entry_subsection_path,
- const std::string & entry_string) const
+ const std::string &entry_string) const
{
try
{
double
ParameterHandler::get_double(
const std::vector<std::string> &entry_subsection_path,
- const std::string & entry_string) const
+ const std::string &entry_string) const
{
try
{
bool
ParameterHandler::get_bool(
const std::vector<std::string> &entry_subsection_path,
- const std::string & entry_string) const
+ const std::string &entry_string) const
{
const std::string s = get(entry_subsection_path, entry_string);
std::ostream &
-ParameterHandler::print_parameters(std::ostream & out,
+ParameterHandler::print_parameters(std::ostream &out,
const OutputStyle style) const
{
AssertThrow(out.fail() == false, ExcIO());
void
ParameterHandler::print_parameters(
- const std::string & filename,
+ const std::string &filename,
const ParameterHandler::OutputStyle style) const
{
std::string extension = filename.substr(filename.find_last_of('.') + 1);
void
ParameterHandler::recursively_print_parameters(
const boost::property_tree::ptree &tree,
- const std::vector<std::string> & target_subsection_path,
+ const std::vector<std::string> &target_subsection_path,
const OutputStyle style,
const unsigned int indent_level,
- std::ostream & out) const
+ std::ostream &out) const
{
AssertThrow(out.fail() == false, ExcIO());
void
-ParameterHandler::log_parameters_section(LogStream & out,
+ParameterHandler::log_parameters_section(LogStream &out,
const OutputStyle style)
{
// Create entries copy and sort it, if needed.
void
-MultipleParameterLoop::parse_input(std::istream & input,
+MultipleParameterLoop::parse_input(std::istream &input,
const std::string &filename,
const std::string &last_line,
const bool skip_undefined)
MultipleParameterLoop::Entry::Entry(const std::vector<std::string> &ssp,
- const std::string & Name,
- const std::string & Value)
+ const std::string &Name,
+ const std::string &Value)
: subsection_path(ssp)
, entry_name(Name)
, entry_value(Value)
ParsedConvergenceTable::ParsedConvergenceTable(
- const std::vector<std::string> & solution_names,
+ const std::vector<std::string> &solution_names,
const std::vector<std::set<VectorTools::NormType>> &list_of_error_norms)
: ParsedConvergenceTable(solution_names,
list_of_error_norms,
ParsedConvergenceTable::ParsedConvergenceTable(
- const std::vector<std::string> & component_names,
+ const std::vector<std::string> &component_names,
const std::vector<std::set<VectorTools::NormType>> &list_of_error_norms,
const double exponent,
- const std::set<std::string> & extra_columns,
- const std::string & rate_key,
- const std::string & rate_mode,
- const std::string & error_file_name,
+ const std::set<std::string> &extra_columns,
+ const std::string &rate_key,
+ const std::string &rate_mode,
+ const std::string &error_file_name,
const unsigned int precision,
const bool compute_error)
: component_names(component_names)
void
ParsedConvergenceTable::add_extra_column(
- const std::string & column_name,
+ const std::string &column_name,
const std::function<double()> &custom_function,
const bool compute_rate)
{
template <int dim>
void
- ParsedFunction<dim>::declare_parameters(ParameterHandler & prm,
+ ParsedFunction<dim>::declare_parameters(ParameterHandler &prm,
const unsigned int n_components)
{
Assert(n_components > 0, ExcZero());
template <int dim>
void
ParsedFunction<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
function_object.vector_value(p, values);
}
std::string
PathSearch::find(const std::string &filename,
const std::string &suffix,
- const char * open_mode)
+ const char *open_mode)
{
std::vector<std::string>::const_iterator path;
const std::vector<std::string>::const_iterator endp = my_path_list.end();
Tuple::Tuple(const std::vector<std::unique_ptr<PatternBase>> &ps,
- const std::string & separator)
+ const std::string &separator)
: separator(separator)
{
Assert(ps.size() > 0,
Tuple::Tuple(const std::vector<std::unique_ptr<PatternBase>> &ps,
- const char * separator)
+ const char *separator)
: Tuple(ps, std::string(separator))
{}
// well if necessary. copy the polynomial to
// do this
std::unique_ptr<Polynomial<number>> q_data;
- const Polynomial<number> * q = nullptr;
+ const Polynomial<number> *q = nullptr;
if (p.in_lagrange_product_form == true)
{
q_data = std::make_unique<Polynomial<number>>(p);
// well if necessary. copy the polynomial to
// do this
std::unique_ptr<Polynomial<number>> q_data;
- const Polynomial<number> * q = nullptr;
+ const Polynomial<number> *q = nullptr;
if (p.in_lagrange_product_form == true)
{
q_data = std::make_unique<Polynomial<number>>(p);
// well if necessary. copy the polynomial to
// do this
std::unique_ptr<Polynomial<number>> q_data;
- const Polynomial<number> * q = nullptr;
+ const Polynomial<number> *q = nullptr;
if (p.in_lagrange_product_form == true)
{
q_data = std::make_unique<Polynomial<number>>(p);
return Monomial<number>(0, 0.);
std::unique_ptr<Polynomial<number>> q_data;
- const Polynomial<number> * q = nullptr;
+ const Polynomial<number> *q = nullptr;
if (in_lagrange_product_form == true)
{
q_data = std::make_unique<Polynomial<number>>(*this);
// no simple form possible for Lagrange
// polynomial on product form
std::unique_ptr<Polynomial<number>> q_data;
- const Polynomial<number> * q = nullptr;
+ const Polynomial<number> *q = nullptr;
if (in_lagrange_product_form == true)
{
q_data = std::make_unique<Polynomial<number>>(*this);
template <int dim>
double
PolynomialSpace<dim>::compute_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const auto ix = compute_index(i);
// take the product of the
template <int dim>
Tensor<1, dim>
PolynomialSpace<dim>::compute_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const auto ix = compute_index(i);
template <int dim>
Tensor<2, dim>
PolynomialSpace<dim>::compute_grad_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const auto ix = compute_index(i);
template <int dim>
void
PolynomialSpace<dim>::evaluate(
- const Point<dim> & p,
- std::vector<double> & values,
+ const Point<dim> &p,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
template <int dim>
void
PolynomialsABF<dim>::evaluate(
- const Point<dim> & unit_point,
+ const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
template <int dim>
void
PolynomialsAdini<dim>::evaluate(
- const Point<dim> & unit_point,
- std::vector<double> & values,
+ const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
template <int dim>
double
PolynomialsAdini<dim>::compute_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const double x = p(0);
const double y = p(1);
template <int dim>
Tensor<1, dim>
PolynomialsAdini<dim>::compute_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const double x = p(0);
const double y = p(1);
template <int dim>
Tensor<2, dim>
PolynomialsAdini<dim>::compute_grad_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const double x = p(0);
const double y = p(1);
template <int dim>
void
BarycentricPolynomials<dim>::evaluate(
- const Point<dim> & unit_point,
- std::vector<double> & values,
+ const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
template <int dim>
double
BarycentricPolynomials<dim>::compute_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertIndexRange(i, this->n());
return polys[i].value(p);
template <int dim>
Tensor<1, dim>
BarycentricPolynomials<dim>::compute_1st_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
Tensor<1, dim> result;
for (unsigned int d = 0; d < dim; ++d)
template <int dim>
Tensor<2, dim>
BarycentricPolynomials<dim>::compute_2nd_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
Tensor<2, dim> result;
for (unsigned int d0 = 0; d0 < dim; ++d0)
template <int dim>
Tensor<3, dim>
BarycentricPolynomials<dim>::compute_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
Tensor<3, dim> result;
for (unsigned int d0 = 0; d0 < dim; ++d0)
template <int dim>
Tensor<4, dim>
BarycentricPolynomials<dim>::compute_4th_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
Tensor<4, dim> result;
for (unsigned int d0 = 0; d0 < dim; ++d0)
template <int dim>
Tensor<1, dim>
BarycentricPolynomials<dim>::compute_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_1st_derivative(i, p);
}
template <int dim>
Tensor<2, dim>
BarycentricPolynomials<dim>::compute_grad_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_2nd_derivative(i, p);
}
template <int dim>
void
PolynomialsBDM<dim>::evaluate(
- const Point<dim> & unit_point,
+ const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
template <int dim>
void
PolynomialsBernardiRaugel<dim>::evaluate(
- const Point<dim> & unit_point,
+ const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
template <int dim>
void
PolynomialsNedelec<dim>::evaluate(
- const Point<dim> & unit_point,
+ const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
void
PiecewisePolynomial<number>::value(const number x,
const unsigned int n_derivatives,
- number * values) const
+ number *values) const
{
if (points.size() > 0)
{
template <int dim>
double
ScalarLagrangePolynomialPyramid<dim>::compute_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertDimension(dim, 3);
AssertIndexRange(this->degree(), 2);
template <int dim>
Tensor<1, dim>
ScalarLagrangePolynomialPyramid<dim>::compute_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertDimension(dim, 3);
AssertIndexRange(this->degree(), 4);
Tensor<2, dim>
ScalarLagrangePolynomialPyramid<dim>::compute_grad_grad(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
(void)i;
(void)p;
template <int dim>
void
ScalarLagrangePolynomialPyramid<dim>::evaluate(
- const Point<dim> & unit_point,
- std::vector<double> & values,
+ const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
Tensor<1, dim>
ScalarLagrangePolynomialPyramid<dim>::compute_1st_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_grad(i, p);
}
Tensor<2, dim>
ScalarLagrangePolynomialPyramid<dim>::compute_2nd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
(void)i;
(void)p;
Tensor<3, dim>
ScalarLagrangePolynomialPyramid<dim>::compute_3rd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
(void)i;
(void)p;
Tensor<4, dim>
ScalarLagrangePolynomialPyramid<dim>::compute_4th_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
(void)i;
(void)p;
template <int dim>
double
PolynomialsRannacherTurek<dim>::compute_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
Assert(dim == 2, ExcNotImplemented());
if (i == 0)
template <int dim>
Tensor<1, dim>
PolynomialsRannacherTurek<dim>::compute_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
Assert(dim == 2, ExcNotImplemented());
Tensor<1, dim> grad;
template <int dim>
void
PolynomialsRannacherTurek<dim>::evaluate(
- const Point<dim> & unit_point,
- std::vector<double> & values,
+ const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
template <int dim>
void
PolynomialsRaviartThomas<dim>::evaluate(
- const Point<dim> & unit_point,
+ const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
template <int dim>
void
PolynomialsRT_Bubbles<dim>::evaluate(
- const Point<dim> & unit_point,
+ const Point<dim> &unit_point,
std::vector<Tensor<1, dim>> &values,
std::vector<Tensor<2, dim>> &grads,
std::vector<Tensor<3, dim>> &grad_grads,
template <int dim>
double
ScalarLagrangePolynomialWedge<dim>::compute_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const auto pair = this->degree() == 1 ? internal::wedge_table_1[i] :
internal::wedge_table_2[i];
template <int dim>
Tensor<1, dim>
ScalarLagrangePolynomialWedge<dim>::compute_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const auto pair = this->degree() == 1 ? internal::wedge_table_1[i] :
internal::wedge_table_2[i];
template <int dim>
void
ScalarLagrangePolynomialWedge<dim>::evaluate(
- const Point<dim> & unit_point,
- std::vector<double> & values,
+ const Point<dim> &unit_point,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
Tensor<1, dim>
ScalarLagrangePolynomialWedge<dim>::compute_1st_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return compute_grad(i, p);
}
Tensor<2, dim>
ScalarLagrangePolynomialWedge<dim>::compute_2nd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
(void)i;
(void)p;
Tensor<3, dim>
ScalarLagrangePolynomialWedge<dim>::compute_3rd_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
(void)i;
(void)p;
Tensor<4, dim>
ScalarLagrangePolynomialWedge<dim>::compute_4th_derivative(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
(void)i;
(void)p;
project_to_hex_face_and_append(
const std::vector<Point<2>> &points,
const unsigned int face_no,
- std::vector<Point<3>> & q_points,
+ std::vector<Point<3>> &q_points,
const RefinementCase<2> &ref_case = RefinementCase<2>::no_refinement,
const unsigned int subface_no = 0)
{
template <>
void
-QProjector<2>::project_to_face(const ReferenceCell & reference_cell,
- const Quadrature<1> & quadrature,
+QProjector<2>::project_to_face(const ReferenceCell &reference_cell,
+ const Quadrature<1> &quadrature,
const unsigned int face_no,
std::vector<Point<2>> &q_points)
{
template <>
void
-QProjector<3>::project_to_face(const ReferenceCell & reference_cell,
- const Quadrature<2> & quadrature,
+QProjector<3>::project_to_face(const ReferenceCell &reference_cell,
+ const Quadrature<2> &quadrature,
const unsigned int face_no,
std::vector<Point<3>> &q_points)
{
template <>
void
-QProjector<2>::project_to_subface(const ReferenceCell & reference_cell,
- const Quadrature<1> & quadrature,
+QProjector<2>::project_to_subface(const ReferenceCell &reference_cell,
+ const Quadrature<1> &quadrature,
const unsigned int face_no,
const unsigned int subface_no,
std::vector<Point<2>> &q_points,
template <>
void
-QProjector<3>::project_to_subface(const ReferenceCell & reference_cell,
- const Quadrature<2> & quadrature,
+QProjector<3>::project_to_subface(const ReferenceCell &reference_cell,
+ const Quadrature<2> &quadrature,
const unsigned int face_no,
const unsigned int subface_no,
- std::vector<Point<3>> & q_points,
+ std::vector<Point<3>> &q_points,
const RefinementCase<2> &ref_case)
{
Assert(reference_cell == ReferenceCells::Hexahedron, ExcNotImplemented());
template <int dim>
Quadrature<dim>
QProjector<dim>::project_to_oriented_subface(
- const ReferenceCell & reference_cell,
+ const ReferenceCell &reference_cell,
const Quadrature<dim - 1> &quadrature,
const unsigned int face_no,
const unsigned int subface_no,
template <>
Quadrature<3>
QProjector<3>::project_to_oriented_subface(
- const ReferenceCell & reference_cell,
- const Quadrature<2> & quadrature,
+ const ReferenceCell &reference_cell,
+ const Quadrature<2> &quadrature,
const unsigned int face_no,
const unsigned int subface_no,
const bool face_orientation,
template <>
Quadrature<1>
-QProjector<1>::project_to_all_faces(const ReferenceCell & reference_cell,
+QProjector<1>::project_to_all_faces(const ReferenceCell &reference_cell,
const hp::QCollection<0> &quadrature)
{
AssertDimension(quadrature.size(), 1);
template <>
Quadrature<2>
-QProjector<2>::project_to_all_faces(const ReferenceCell & reference_cell,
+QProjector<2>::project_to_all_faces(const ReferenceCell &reference_cell,
const hp::QCollection<1> &quadrature)
{
if (reference_cell == ReferenceCells::Triangle)
const auto support_points_line =
[](const auto &face, const auto &orientation) -> std::vector<Point<2>> {
// MSVC struggles when using face.first.begin()
- const Point<2, double> * vertices_ptr = &face.first[0];
+ const Point<2, double> *vertices_ptr = &face.first[0];
ArrayView<const Point<2>> vertices(vertices_ptr, face.first.size());
const auto temp =
ReferenceCells::Line.permute_by_combined_orientation(vertices,
template <>
Quadrature<3>
-QProjector<3>::project_to_all_faces(const ReferenceCell & reference_cell,
+QProjector<3>::project_to_all_faces(const ReferenceCell &reference_cell,
const hp::QCollection<2> &quadrature)
{
const auto process = [&](const std::vector<std::vector<Point<3>>> &faces) {
template <int dim>
Quadrature<dim>
-QProjector<dim>::project_to_child(const ReferenceCell & reference_cell,
+QProjector<dim>::project_to_child(const ReferenceCell &reference_cell,
const Quadrature<dim> &quadrature,
const unsigned int child_no)
{
template <int dim>
Quadrature<dim>
-QProjector<dim>::project_to_all_children(const ReferenceCell & reference_cell,
+QProjector<dim>::project_to_all_children(const ReferenceCell &reference_cell,
const Quadrature<dim> &quadrature)
{
Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
Quadrature<dim>
QProjector<dim>::project_to_line(const ReferenceCell &reference_cell,
const Quadrature<1> &quadrature,
- const Point<dim> & p1,
- const Point<dim> & p2)
+ const Point<dim> &p1,
+ const Point<dim> &p2)
{
Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
template <int dim>
typename QProjector<dim>::DataSetDescriptor
QProjector<dim>::DataSetDescriptor::face(
- const ReferenceCell & reference_cell,
+ const ReferenceCell &reference_cell,
const unsigned int face_no,
const bool face_orientation,
const bool face_flip,
template <>
QProjector<3>::DataSetDescriptor
QProjector<3>::DataSetDescriptor::subface(
- const ReferenceCell & reference_cell,
+ const ReferenceCell &reference_cell,
const unsigned int face_no,
const unsigned int subface_no,
const bool face_orientation,
template <int dim>
void
Quadrature<dim>::initialize(const std::vector<Point<dim>> &p,
- const std::vector<double> & w)
+ const std::vector<double> &w)
{
AssertDimension(w.size(), p.size());
quadrature_points = p;
template <int dim>
Quadrature<dim>::Quadrature(const std::vector<Point<dim>> &points,
- const std::vector<double> & weights)
+ const std::vector<double> &weights)
: quadrature_points(points)
, weights(weights)
, is_tensor_product_flag(dim == 1)
template <int dim>
Quadrature<dim>::Quadrature(std::vector<Point<dim>> &&points,
- std::vector<double> && weights)
+ std::vector<double> &&weights)
: quadrature_points(std::move(points))
, weights(std::move(weights))
, is_tensor_product_flag(dim == 1)
template <>
-QIterated<1>::QIterated(const Quadrature<1> & base_quadrature,
+QIterated<1>::QIterated(const Quadrature<1> &base_quadrature,
const std::vector<Point<1>> &intervals)
: Quadrature<1>(
internal::QIteratedImplementation::uses_both_endpoints(base_quadrature) ?
// construct higher dimensional quadrature formula by tensor product
// of lower dimensional iterated quadrature formulae
template <int dim>
-QIterated<dim>::QIterated(const Quadrature<1> & base_quadrature,
+QIterated<dim>::QIterated(const Quadrature<1> &base_quadrature,
const std::vector<Point<1>> &intervals)
: Quadrature<dim>(QIterated<dim - 1>(base_quadrature, intervals),
QIterated<1>(base_quadrature, intervals))
template <>
QGaussLogR<1>::QGaussLogR(const unsigned int n,
- const Point<1> & origin,
+ const Point<1> &origin,
const double alpha,
const bool factor_out_singularity)
: Quadrature<1>(
template <>
QGaussOneOverR<2>::QGaussOneOverR(const unsigned int n,
- const Point<2> & singularity,
+ const Point<2> &singularity,
const bool factor_out_singularity)
: Quadrature<2>(quad_size(singularity, n))
{
// And we get rid of R to take into account the singularity,
// unless specified differently in the constructor.
std::vector<Point<2>> &ps = this->quadrature_points;
- std::vector<double> & ws = this->weights;
+ std::vector<double> &ws = this->weights;
double pi4 = numbers::PI / 4;
for (unsigned int q = 0; q < gauss.size(); ++q)
template <int dim>
QTelles<dim>::QTelles(const Quadrature<1> &base_quad,
- const Point<dim> & singularity)
+ const Point<dim> &singularity)
: // We need the explicit implementation if dim == 1. If dim > 1 we use the
// former implementation and apply a tensorial product to obtain the higher
// dimensions.
void
Subscriptor::subscribe(std::atomic<bool> *const validity,
- const std::string & id) const
+ const std::string &id) const
{
std::lock_guard<std::mutex> lock(mutex);
void
Subscriptor::unsubscribe(std::atomic<bool> *const validity,
- const std::string & id) const
+ const std::string &id) const
{
const std::string &name = id.empty() ? unknown_subscriber : id;
template <int rank, int dim, typename Number>
void
TensorFunctionParser<rank, dim, Number>::initialize(
- const std::string & variables,
- const std::vector<std::string> & expressions,
+ const std::string &variables,
+ const std::vector<std::string> &expressions,
const std::map<std::string, double> &constants,
const bool time_dependent)
{
template <int rank, int dim, typename Number>
void
TensorFunctionParser<rank, dim, Number>::initialize(
- const std::string & vars,
- const std::string & expression,
+ const std::string &vars,
+ const std::string &expression,
const std::map<std::string, double> &constants,
const bool time_dependent)
{
template <int rank, int dim, typename Number>
void
TensorFunctionParser<rank, dim, Number>::value_list(
- const std::vector<Point<dim>> & p,
+ const std::vector<Point<dim>> &p,
std::vector<Tensor<rank, dim, Number>> &values) const
{
Assert(p.size() == values.size(),
double
TensorProductPolynomials<dim, PolynomialType>::compute_value(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
Assert(dim > 0, ExcNotImplemented());
Tensor<1, dim>
TensorProductPolynomials<dim, PolynomialType>::compute_grad(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
std::array<unsigned int, dim> indices;
compute_index(i, indices);
Tensor<2, dim>
TensorProductPolynomials<dim, PolynomialType>::compute_grad_grad(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
std::array<unsigned int, dim> indices;
compute_index(i, indices);
template <int dim, typename PolynomialType>
void
TensorProductPolynomials<dim, PolynomialType>::evaluate(
- const Point<dim> & p,
- std::vector<double> & values,
+ const Point<dim> &p,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
#endif
if (dim == 0)
- {}
+ {
+ }
else if (dim == 1)
internal::compute_tensor_index(i,
polynomials[0].size(),
template <int dim>
double
AnisotropicPolynomials<dim>::compute_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
std::array<unsigned int, dim> indices;
compute_index(i, indices);
template <int dim>
Tensor<1, dim>
AnisotropicPolynomials<dim>::compute_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
std::array<unsigned int, dim> indices;
compute_index(i, indices);
template <int dim>
Tensor<2, dim>
AnisotropicPolynomials<dim>::compute_grad_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
std::array<unsigned int, dim> indices;
compute_index(i, indices);
template <int dim>
void
AnisotropicPolynomials<dim>::evaluate(
- const Point<dim> & p,
- std::vector<double> & values,
+ const Point<dim> &p,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
template <int dim>
double
TensorProductPolynomialsBubbles<dim>::compute_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const unsigned int q_degree = tensor_polys.polynomials.size() - 1;
const unsigned int max_q_indices = tensor_polys.n();
template <int dim>
Tensor<1, dim>
TensorProductPolynomialsBubbles<dim>::compute_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const unsigned int q_degree = tensor_polys.polynomials.size() - 1;
const unsigned int max_q_indices = tensor_polys.n();
Tensor<2, dim>
TensorProductPolynomialsBubbles<dim>::compute_grad_grad(
const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const unsigned int q_degree = tensor_polys.polynomials.size() - 1;
const unsigned int max_q_indices = tensor_polys.n();
template <int dim>
void
TensorProductPolynomialsBubbles<dim>::evaluate(
- const Point<dim> & p,
- std::vector<double> & values,
+ const Point<dim> &p,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
template <int dim>
double
TensorProductPolynomialsConst<dim>::compute_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const unsigned int max_indices = tensor_polys.n();
Assert(i <= max_indices, ExcInternalError());
template <int dim>
Tensor<1, dim>
TensorProductPolynomialsConst<dim>::compute_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const unsigned int max_indices = tensor_polys.n();
Assert(i <= max_indices, ExcInternalError());
template <int dim>
void
TensorProductPolynomialsConst<dim>::evaluate(
- const Point<dim> & p,
- std::vector<double> & values,
+ const Point<dim> &p,
+ std::vector<double> &values,
std::vector<Tensor<1, dim>> &grads,
std::vector<Tensor<2, dim>> &grad_grads,
std::vector<Tensor<3, dim>> &third_derivatives,
if (sync_lap_times)
{
wall_times.last_lap_time =
- internal::TimerImplementation::from_seconds<decltype(
- wall_times)::duration_type>(last_lap_wall_time_data.max);
- cpu_times.last_lap_time =
- internal::TimerImplementation::from_seconds<decltype(
- cpu_times)::duration_type>(
- Utilities::MPI::min_max_avg(
- internal::TimerImplementation::to_seconds(
- cpu_times.last_lap_time),
- mpi_communicator)
- .max);
+ internal::TimerImplementation::from_seconds<
+ decltype(wall_times)::duration_type>(last_lap_wall_time_data.max);
+ cpu_times.last_lap_time = internal::TimerImplementation::from_seconds<
+ decltype(cpu_times)::duration_type>(
+ Utilities::MPI::min_max_avg(
+ internal::TimerImplementation::to_seconds(
+ cpu_times.last_lap_time),
+ mpi_communicator)
+ .max);
}
wall_times.accumulated_time += wall_times.last_lap_time;
cpu_times.accumulated_time += cpu_times.last_lap_time;
/* ---------------------------- TimerOutput -------------------------- */
-TimerOutput::TimerOutput(std::ostream & stream,
+TimerOutput::TimerOutput(std::ostream &stream,
const OutputFrequency output_frequency,
const OutputType output_type)
: output_frequency(output_frequency)
-TimerOutput::TimerOutput(ConditionalOStream & stream,
+TimerOutput::TimerOutput(ConditionalOStream &stream,
const OutputFrequency output_frequency,
const OutputType output_type)
: output_frequency(output_frequency)
TimerOutput::TimerOutput(const MPI_Comm mpi_communicator,
- std::ostream & stream,
+ std::ostream &stream,
const OutputFrequency output_frequency,
const OutputType output_type)
: output_frequency(output_frequency)
TimerOutput::TimerOutput(const MPI_Comm mpi_communicator,
- ConditionalOStream & stream,
+ ConditionalOStream &stream,
const OutputFrequency output_frequency,
const OutputType output_type)
: output_frequency(output_frequency)
std::vector<std::array<std::uint64_t, effective_dim>>
inverse_Hilbert_space_filling_curve_effective(
const std::vector<Point<dim, Number>> &points,
- const Point<dim, Number> & bl,
- const std::array<LongDouble, dim> & extents,
- const std::bitset<dim> & valid_extents,
+ const Point<dim, Number> &bl,
+ const std::array<LongDouble, dim> &extents,
+ const std::bitset<dim> &valid_extents,
const int min_bits,
const Integer max_int)
{
get_time()
{
std::time_t time1 = std::time(nullptr);
- std::tm * time = std::localtime(&time1);
+ std::tm *time = std::localtime(&time1);
std::ostringstream o;
o << time->tm_hour << ":" << (time->tm_min < 10 ? "0" : "")
get_date()
{
std::time_t time1 = std::time(nullptr);
- std::tm * time = std::localtime(&time1);
+ std::tm *time = std::localtime(&time1);
std::ostringstream o;
o << time->tm_year + 1900 << "/" << time->tm_mon + 1 << "/"
void
- mark_domains(CDT & ct,
+ mark_domains(CDT &ct,
Face_handle start,
int index,
std::list<CDT::Edge> &border)
if (!intersection_test.empty())
{
- const auto & poly = intersection_test[0].outer_boundary();
+ const auto &poly = intersection_test[0].outer_boundary();
const unsigned int size_poly = poly.size();
if (size_poly == 3)
{
compute_intersection_of_cells(
const typename Triangulation<dim0, spacedim>::cell_iterator &cell0,
const typename Triangulation<dim1, spacedim>::cell_iterator &cell1,
- const Mapping<dim0, spacedim> & mapping0,
- const Mapping<dim1, spacedim> & mapping1,
+ const Mapping<dim0, spacedim> &mapping0,
+ const Mapping<dim1, spacedim> &mapping1,
const double tol)
{
Assert(mapping0.get_vertices(cell0).size() ==
compute_intersection_of_cells(
const typename Triangulation<dim0, spacedim>::cell_iterator &cell0,
const typename Triangulation<dim1, spacedim>::cell_iterator &cell1,
- const Mapping<dim0, spacedim> & mapping0,
- const Mapping<dim1, spacedim> & mapping1,
+ const Mapping<dim0, spacedim> &mapping0,
+ const Mapping<dim1, spacedim> &mapping1,
const double tol)
{
(void)cell0;
compute_intersection_of_cells<dim0, dim1, spacedim>(
const typename Triangulation<dim0, spacedim>::cell_iterator &cell0,
const typename Triangulation<dim1, spacedim>::cell_iterator &cell1,
- const Mapping<dim0, spacedim> & mapping0,
- const Mapping<dim1, spacedim> & mapping1,
+ const Mapping<dim0, spacedim> &mapping0,
+ const Mapping<dim1, spacedim> &mapping1,
const double tol);
template std::vector<std::array<Point<spacedim>, dim1 + 1>>
template <typename dealiiFace, typename CGAL_Mesh>
void
add_facet(
- const dealiiFace & face,
+ const dealiiFace &face,
const std::map<unsigned int, typename CGAL_Mesh::Vertex_index> &deal2cgal,
- CGAL_Mesh & mesh,
+ CGAL_Mesh &mesh,
const bool clockwise_ordering = true)
{
const auto reference_cell_type = face->reference_cell();
template <typename dealiiFace, typename CGAL_Mesh>
void
map_vertices(
- const dealiiFace & cell,
+ const dealiiFace &cell,
std::map<unsigned int, typename CGAL_Mesh::Vertex_index> &deal2cgal,
- CGAL_Mesh & mesh)
+ CGAL_Mesh &mesh)
{
for (const auto i : cell->vertex_indices())
{
void
dealii_cell_to_cgal_surface_mesh(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Mapping<dim, spacedim> & mapping,
- CGAL::Surface_mesh<CGALPointType> & mesh)
+ const Mapping<dim, spacedim> &mapping,
+ CGAL::Surface_mesh<CGALPointType> &mesh)
{
Assert(dim > 1, ExcImpossibleInDim(dim));
using Mesh = CGAL::Surface_mesh<CGALPointType>;
void
dealii_tria_to_cgal_surface_mesh(
const dealii::Triangulation<dim, spacedim> &tria,
- CGAL::Surface_mesh<CGALPointType> & mesh)
+ CGAL::Surface_mesh<CGALPointType> &mesh)
{
Assert(tria.n_cells() > 0,
ExcMessage(
dim,
spacedim>(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Mapping<dim, spacedim> & mapping,
- CGAL::Surface_mesh<typename cgal_kernel::Point_3> & mesh);
+ const Mapping<dim, spacedim> &mapping,
+ CGAL::Surface_mesh<typename cgal_kernel::Point_3> &mesh);
template void dealii_tria_to_cgal_surface_mesh<
typename cgal_kernel::Point_3,
dim,
- spacedim>(const Triangulation<dim, spacedim> & cell,
+ spacedim>(const Triangulation<dim, spacedim> &cell,
CGAL::Surface_mesh<typename cgal_kernel::Point_3> &mesh);
#endif
}
NumberTypes::adolc_taped>>::
print_tape_stats(
const typename Types<ADNumberType>::tape_index tape_index,
- std::ostream & stream) const
+ std::ostream &stream) const
{
// See ADOL-C manual section 2.1
// and adolc/taping.h
NumberTypes::adolc_taped>>::
gradient(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
- Vector<scalar_type> & gradient) const
+ Vector<scalar_type> &gradient) const
{
Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
1,
NumberTypes::adolc_taped>>::
hessian(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
- FullMatrix<scalar_type> & hessian) const
+ FullMatrix<scalar_type> &hessian) const
{
Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
2,
values(const typename Types<ADNumberType>::tape_index active_tape_index,
const unsigned int n_dependent_variables,
const std::vector<scalar_type> &independent_variables,
- Vector<scalar_type> & values) const
+ Vector<scalar_type> &values) const
{
Assert(values.size() == n_dependent_variables,
ExcDimensionMismatch(values.size(), n_dependent_variables));
jacobian(const typename Types<ADNumberType>::tape_index active_tape_index,
const unsigned int n_dependent_variables,
const std::vector<scalar_type> &independent_variables,
- FullMatrix<scalar_type> & jacobian) const
+ FullMatrix<scalar_type> &jacobian) const
{
Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
1,
NumberTypes::adolc_taped>>::
print_tape_stats(
const typename Types<ADNumberType>::tape_index tape_index,
- std::ostream & stream) const
+ std::ostream &stream) const
{
// ADOL-C only supports 'double', not 'float', so we can forward to
// the 'double' implementation of this function
NumberTypes::adolc_taped>>::
gradient(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
- Vector<scalar_type> & gradient) const
+ Vector<scalar_type> &gradient) const
{
Vector<double> gradient_double(gradient.size());
// ADOL-C only supports 'double', not 'float', so we can forward to
NumberTypes::adolc_taped>>::
hessian(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
- FullMatrix<scalar_type> & hessian) const
+ FullMatrix<scalar_type> &hessian) const
{
FullMatrix<double> hessian_double(hessian.m(), hessian.n());
// ADOL-C only supports 'double', not 'float', so we can forward to
values(const typename Types<ADNumberType>::tape_index active_tape_index,
const unsigned int n_dependent_variables,
const std::vector<scalar_type> &independent_variables,
- Vector<scalar_type> & values) const
+ Vector<scalar_type> &values) const
{
Vector<double> values_double(values.size());
// ADOL-C only supports 'double', not 'float', so we can forward to
jacobian(const typename Types<ADNumberType>::tape_index active_tape_index,
const unsigned int n_dependent_variables,
const std::vector<scalar_type> &independent_variables,
- FullMatrix<scalar_type> & jacobian) const
+ FullMatrix<scalar_type> &jacobian) const
{
FullMatrix<double> jacobian_double(jacobian.m(), jacobian.n());
// ADOL-C only supports 'double', not 'float', so we can forward to
NumberTypes::sacado_rad_dfad>>::
gradient(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- Vector<ScalarType> & gradient) const
+ Vector<ScalarType> &gradient) const
{
Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
1,
NumberTypes::sacado_rad_dfad>>::
hessian(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- FullMatrix<ScalarType> & hessian) const
+ FullMatrix<ScalarType> &hessian) const
{
Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
2,
ADNumberTraits<ADNumberType>::type_code ==
NumberTypes::sacado_rad_dfad>>::
values(const std::vector<ADNumberType> &dependent_variables,
- Vector<ScalarType> & values) const
+ Vector<ScalarType> &values) const
{
Assert(values.size() == dependent_variables.size(),
ExcDimensionMismatch(values.size(), dependent_variables.size()));
NumberTypes::sacado_rad_dfad>>::
jacobian(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- FullMatrix<ScalarType> & jacobian) const
+ FullMatrix<ScalarType> &jacobian) const
{
Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
1,
NumberTypes::sacado_dfad_dfad>>::
gradient(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- Vector<ScalarType> & gradient) const
+ Vector<ScalarType> &gradient) const
{
Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
1,
NumberTypes::sacado_dfad_dfad>>::
hessian(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- FullMatrix<ScalarType> & hessian) const
+ FullMatrix<ScalarType> &hessian) const
{
Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
2,
ADNumberTraits<ADNumberType>::type_code ==
NumberTypes::sacado_dfad_dfad>>::
values(const std::vector<ADNumberType> &dependent_variables,
- Vector<ScalarType> & values) const
+ Vector<ScalarType> &values) const
{
Assert(values.size() == dependent_variables.size(),
ExcDimensionMismatch(values.size(), dependent_variables.size()));
NumberTypes::sacado_dfad_dfad>>::
jacobian(const std::vector<ADNumberType> &independent_variables,
const std::vector<ADNumberType> &dependent_variables,
- FullMatrix<ScalarType> & jacobian) const
+ FullMatrix<ScalarType> &jacobian) const
{
Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
1,
void
HelperBase<ADNumberTypeCode, ScalarType>::mark_independent_variable(
const unsigned int index,
- ad_type & out) const
+ ad_type &out) const
{
Assert(index < n_independent_variables(), ExcInternalError());
Assert(registered_independent_variable_values[index] == true,
void
HelperBase<ADNumberTypeCode, ScalarType>::print_tape_stats(
const typename Types<ad_type>::tape_index tape_index,
- std::ostream & stream) const
+ std::ostream &stream) const
{
if (ADNumberTraits<ad_type>::is_tapeless == true)
return;
void
HelperBase<ADNumberTypeCode, ScalarType>::register_dependent_variable(
const unsigned int index,
- const ad_type & func)
+ const ad_type &func)
{
Assert(index < n_dependent_variables(), ExcMessage("Index out of range"));
Assert(registered_marked_dependent_variables[index] == false,
dim,
typename ScalarFunction<dim, ADNumberTypeCode, ScalarType>::scalar_type>
ScalarFunction<dim, ADNumberTypeCode, ScalarType>::
- extract_hessian_component(const FullMatrix<scalar_type> & hessian,
+ extract_hessian_component(const FullMatrix<scalar_type> &hessian,
const FEValuesExtractors::Scalar &extractor_row,
const FEValuesExtractors::Scalar &extractor_col)
{
typename ScalarFunction<dim, ADNumberTypeCode, ScalarType>::scalar_type>
ScalarFunction<dim, ADNumberTypeCode, ScalarType>::
extract_hessian_component(
- const FullMatrix<scalar_type> & hessian,
+ const FullMatrix<scalar_type> &hessian,
const FEValuesExtractors::SymmetricTensor<2> &extractor_row,
const FEValuesExtractors::SymmetricTensor<2> &extractor_col)
{
typename VectorFunction<dim, ADNumberTypeCode, ScalarType>::scalar_type>
VectorFunction<dim, ADNumberTypeCode, ScalarType>::
extract_jacobian_component(
- const FullMatrix<scalar_type> & jacobian,
+ const FullMatrix<scalar_type> &jacobian,
const FEValuesExtractors::Scalar &extractor_row,
const FEValuesExtractors::Scalar &extractor_col)
{
typename VectorFunction<dim, ADNumberTypeCode, ScalarType>::scalar_type>
VectorFunction<dim, ADNumberTypeCode, ScalarType>::
extract_jacobian_component(
- const FullMatrix<scalar_type> & jacobian,
+ const FullMatrix<scalar_type> &jacobian,
const FEValuesExtractors::SymmetricTensor<2> &extractor_row,
const FEValuesExtractors::SymmetricTensor<2> &extractor_col)
{
Expression::Expression(const std::vector<std::pair<Expression, Expression>>
- & condition_expression,
+ &condition_expression,
const Expression &expression_otherwise)
{
SE::PiecewiseVec piecewise_function;
}
- Expression::Expression(const std::string & symbol_func,
+ Expression::Expression(const std::string &symbol_func,
const types::symbol_vector &arguments)
: expression(SE::function_symbol(
symbol_func,
template <typename ReturnType>
BatchOptimizer<ReturnType>::BatchOptimizer(
- const enum OptimizerType & optimization_method,
+ const enum OptimizerType &optimization_method,
const enum OptimizationFlags &optimization_flags)
: BatchOptimizer()
{
template <typename ReturnType>
void
BatchOptimizer<ReturnType>::set_optimization_method(
- const enum OptimizerType & optimization_method,
+ const enum OptimizerType &optimization_method,
const enum OptimizationFlags &optimization_flags)
{
Assert(
void
BatchOptimizer<ReturnType>::substitute(
const SD::types::symbol_vector &symbols,
- const std::vector<ReturnType> & values) const
+ const std::vector<ReturnType> &values) const
{
// Zip the two vectors and use the other function call
// This ensures the ordering of the input vectors matches that of the
template <typename ReturnType>
void
BatchOptimizer<ReturnType>::substitute(
- const SymEngine::vec_basic & symbols,
+ const SymEngine::vec_basic &symbols,
const std::vector<ReturnType> &values) const
{
substitute(SD::Utilities::convert_basic_vector_to_expression_vector(
template <typename ReturnType>
ReturnType
BatchOptimizer<ReturnType>::extract(
- const Expression & func,
+ const Expression &func,
const std::vector<ReturnType> &cached_evaluation) const
{
// TODO[JPP]: Find a way to fix this bug that crops up in serialization
# ifndef DOXYGEN
Expression
- make_symbolic_function(const std::string & symbol,
+ make_symbolic_function(const std::string &symbol,
const SD::types::symbol_vector &arguments)
{
return Expression(symbol, arguments);
Expression
- make_symbolic_function(const std::string & symbol,
+ make_symbolic_function(const std::string &symbol,
const SD::types::substitution_map &arguments)
{
return make_symbolic_function(symbol,
void
set_value_in_symbol_map(
- types::substitution_map & substitution_map,
+ types::substitution_map &substitution_map,
const SymEngine::RCP<const SymEngine::Basic> &symbol,
const SymEngine::RCP<const SymEngine::Basic> &value)
{
void
set_value_in_symbol_map(types::substitution_map &substitution_map,
- const Expression & symbol,
- const Expression & value)
+ const Expression &symbol,
+ const Expression &value)
{
internal::set_value_in_symbol_map(substitution_map,
symbol.get_RCP(),
void
- set_value_in_symbol_map(types::substitution_map & substitution_map,
+ set_value_in_symbol_map(types::substitution_map &substitution_map,
const types::substitution_map &symbol_values)
{
for (const auto &entry : symbol_values)
void
- merge_substitution_maps(types::substitution_map & symb_map_out,
+ merge_substitution_maps(types::substitution_map &symb_map_out,
const types::substitution_map &symb_map_in)
{
// Do this by hand so that we can perform some sanity checks
// Instead of checking by value (and thus having
// to store a temporary value), we check to see
// if the hash of the map entry changes.
- Expression & out = entry.second;
+ Expression &out = entry.second;
SE::hash_t hash_old;
SE::hash_t hash_new = out.get_RCP()->hash();
unsigned int iter = 0;
Expression
- substitute(const Expression & expression,
+ substitute(const Expression &expression,
const types::substitution_map &substitution_map)
{
return expression.substitute(substitution_map);
struct Symbol_Function_Tensor
{
static Tensor<rank, dim, Expression>
- create(const std::string & sym,
+ create(const std::string &sym,
const types::substitution_map &arguments)
{
Tensor<rank, dim, Expression> out;
struct Symbol_Function_Tensor<0, dim>
{
static Tensor<0, dim, Expression>
- create(const std::string & sym,
+ create(const std::string &sym,
const types::substitution_map &arguments)
{
return make_symbolic_function(sym, arguments);
struct Symbol_Function_SymmetricTensor
{
static SymmetricTensor<2, dim, Expression>
- create(const std::string & sym,
+ create(const std::string &sym,
const types::substitution_map &arguments)
{
SymmetricTensor<rank, dim, Expression> out;
struct Symbol_Function_SymmetricTensor<4, dim>
{
static SymmetricTensor<4, dim, Expression>
- create(const std::string & sym,
+ create(const std::string &sym,
const types::substitution_map &arguments)
{
SymmetricTensor<4, dim, Expression> out;
# ifndef DOXYGEN
template <int dim>
Tensor<1, dim, Expression>
- make_vector_of_symbolic_functions(const std::string & sym,
+ make_vector_of_symbolic_functions(const std::string &sym,
const types::substitution_map &arguments)
{
return internal::Symbol_Function_Tensor<1, dim>::create(sym, arguments);
# ifndef DOXYGEN
template <int rank, int dim>
Tensor<rank, dim, Expression>
- make_tensor_of_symbolic_functions(const std::string & sym,
+ make_tensor_of_symbolic_functions(const std::string &sym,
const types::substitution_map &arguments)
{
return internal::Symbol_Function_Tensor<rank, dim>::create(sym,
template <int rank, int dim>
SymmetricTensor<rank, dim, Expression>
make_symmetric_tensor_of_symbolic_functions(
- const std::string & sym,
+ const std::string &sym,
const types::substitution_map &arguments)
{
return internal::Symbol_Function_SymmetricTensor<rank, dim>::create(
template Tensor<1, deal_II_dimension, Expression>
make_vector_of_symbolic_functions<deal_II_dimension>(
- const std::string & symbol,
+ const std::string &symbol,
const types::substitution_map &arguments);
/*--- Rank-0 definitions ---*/
template Tensor<0, deal_II_dimension, Expression>
make_tensor_of_symbolic_functions<0, deal_II_dimension>(
- const std::string & symbol,
+ const std::string &symbol,
const types::substitution_map &arguments);
\}
\}
template Tensor<rank, deal_II_dimension, Expression>
make_tensor_of_symbolic_functions<rank, deal_II_dimension>(
- const std::string & symbol,
+ const std::string &symbol,
const types::substitution_map &arguments);
\}
template SymmetricTensor<rank, deal_II_dimension, Expression>
make_symmetric_tensor_of_symbolic_functions<rank, deal_II_dimension>(
- const std::string & symbol,
+ const std::string &symbol,
const types::substitution_map &arguments);
\}
template <int dim, int spacedim>
CellWeights<dim, spacedim>::CellWeights(
const DoFHandler<dim, spacedim> &dof_handler,
- const WeightingFunction & weighting_function)
+ const WeightingFunction &weighting_function)
{
reinit(dof_handler, weighting_function);
}
return [&dof_handler, tria, weighting_function](
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status) -> unsigned int {
return CellWeights<dim, spacedim>::weighting_callback(cell,
status,
CellWeights<dim, spacedim>::weighting_callback(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator &cell_,
const CellStatus status,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const parallel::TriangulationBase<dim, spacedim> &triangulation,
const typename CellWeights<dim, spacedim>::WeightingFunction
&weighting_function)
const auto coarsening_strategy =
[this](
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & parent,
+ &parent,
const std::vector<Vector<Number>> &children_values) {
// get the equivalent DoFCellAccessor
typename DoFHandler<dim, spacedim>::cell_iterator dof_cell_iterator(
void
FieldTransfer<dim, VectorType, spacedim>::
prepare_for_coarsening_and_refinement(
- const VectorType & in,
+ const VectorType &in,
const unsigned int fe_nothing_index)
{
const unsigned int dofs_per_cell =
template <int dim, typename VectorType, int spacedim>
void
FieldTransfer<dim, VectorType, spacedim>::interpolate(
- const Number & new_value,
+ const Number &new_value,
const AffineConstraints<Number> &affine_constraints,
- VectorType & out)
+ VectorType &out)
{
const unsigned int dofs_per_cell =
dof_handler.get_fe_collection().max_dofs_per_cell();
template <int dim, int spacedim>
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
void Triangulation<dim, spacedim>::create_triangulation(
- const std::vector<Point<spacedim>> & vertices,
+ const std::vector<Point<spacedim>> &vertices,
const std::vector<dealii::CellData<dim>> &cells,
- const SubCellData & subcelldata)
+ const SubCellData &subcelldata)
{
Assert(
currently_processing_create_triangulation_for_internal_usage,
void Triangulation<dim, spacedim>::set_partitioner(
const std::function<void(dealii::Triangulation<dim, spacedim> &,
const unsigned int)> &partitioner,
- const TriangulationDescription::Settings & settings)
+ const TriangulationDescription::Settings &settings)
{
this->partitioner = partitioner;
this->settings = settings;
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
void Triangulation<dim, spacedim>::set_partitioner(
const RepartitioningPolicyTools::Base<dim, spacedim> &partitioner,
- const TriangulationDescription::Settings & settings)
+ const TriangulationDescription::Settings &settings)
{
this->partitioner_distributed = &partitioner;
this->settings = settings;
template <int dim, int spacedim, typename Number>
void
mark_cells(dealii::Triangulation<dim, spacedim> &tria,
- const dealii::Vector<Number> & criteria,
+ const dealii::Vector<Number> &criteria,
const double top_threshold,
const double bottom_threshold)
{
void
refine_and_coarsen_fixed_fraction_via_l1_norm(
dealii::Triangulation<dim, spacedim> &tria,
- const dealii::Vector<Number> & criteria,
+ const dealii::Vector<Number> &criteria,
const double top_fraction_of_error,
const double bottom_fraction_of_error)
{
{
template <typename number>
number
- compute_threshold(const dealii::Vector<number> & criteria,
+ compute_threshold(const dealii::Vector<number> &criteria,
const std::pair<double, double> &global_min_and_max,
const types::global_cell_index n_target_cells,
const MPI_Comm mpi_communicator)
{
template <typename number>
number
- compute_threshold(const dealii::Vector<number> & criteria,
+ compute_threshold(const dealii::Vector<number> &criteria,
const std::pair<double, double> &global_min_and_max,
const double target_error,
const MPI_Comm mpi_communicator)
void
refine_and_coarsen_fixed_number(
dealii::Triangulation<dim, spacedim> &tria,
- const dealii::Vector<Number> & criteria,
+ const dealii::Vector<Number> &criteria,
const double top_fraction_of_cells,
const double bottom_fraction_of_cells,
const types::global_cell_index max_n_cells)
void
refine_and_coarsen_fixed_fraction(
dealii::Triangulation<dim, spacedim> &tria,
- const dealii::Vector<Number> & criteria,
+ const dealii::Vector<Number> &criteria,
const double top_fraction_of_error,
const double bottom_fraction_of_error,
const VectorTools::NormType norm_type)
{
const typename dealii::parallel::distributed::Triangulation<dim,
spacedim>
- * triangulation;
+ *triangulation;
sc_array_t *subids;
std::map<unsigned int, std::set<dealii::types::subdomain_id>>
*vertices_with_ghost_neighbors;
void
find_ghosts_corner(
typename dealii::internal::p4est::iter<dim>::corner_info *info,
- void * user_data)
+ void *user_data)
{
int i, j;
int nsides = info->sides.elem_count;
static_cast<FindGhosts<dim, spacedim> *>(user_data);
sc_array_t *subids = fg->subids;
const dealii::parallel::distributed::Triangulation<dim, spacedim>
- * triangulation = fg->triangulation;
+ *triangulation = fg->triangulation;
int nsubs;
dealii::types::subdomain_id *subdomain_ids;
std::map<unsigned int, std::set<dealii::types::subdomain_id>>
void
find_ghosts_edge(
typename dealii::internal::p4est::iter<dim>::edge_info *info,
- void * user_data)
+ void *user_data)
{
int i, j, k;
int nsides = info->sides.elem_count;
auto *sides = reinterpret_cast<
typename dealii::internal::p4est::iter<dim>::edge_side *>(
info->sides.array);
- auto * fg = static_cast<FindGhosts<dim, spacedim> *>(user_data);
+ auto *fg = static_cast<FindGhosts<dim, spacedim> *>(user_data);
sc_array_t *subids = fg->subids;
const dealii::parallel::distributed::Triangulation<dim, spacedim>
- * triangulation = fg->triangulation;
+ *triangulation = fg->triangulation;
int nsubs;
dealii::types::subdomain_id *subdomain_ids;
std::map<unsigned int, std::set<dealii::types::subdomain_id>>
void
find_ghosts_face(
typename dealii::internal::p4est::iter<dim>::face_info *info,
- void * user_data)
+ void *user_data)
{
int i, j, k;
int nsides = info->sides.elem_count;
static_cast<FindGhosts<dim, spacedim> *>(user_data);
sc_array_t *subids = fg->subids;
const dealii::parallel::distributed::Triangulation<dim, spacedim>
- * triangulation = fg->triangulation;
+ *triangulation = fg->triangulation;
int nsubs;
dealii::types::subdomain_id *subdomain_ids;
std::map<unsigned int, std::set<dealii::types::subdomain_id>>
- * vertices_with_ghost_neighbors = fg->vertices_with_ghost_neighbors;
+ *vertices_with_ghost_neighbors = fg->vertices_with_ghost_neighbors;
int limit = (dim == 2) ? 2 : 4;
subids->elem_count = 0;
types<2>::quadrant c[]) =
p4est_quadrant_childrenv;
- int (&functions<2>::quadrant_overlaps_tree)(types<2>::tree * tree,
+ int (&functions<2>::quadrant_overlaps_tree)(types<2>::tree *tree,
const types<2>::quadrant *q) =
p4est_quadrant_overlaps_tree;
int level) =
p4est_quadrant_ancestor_id;
- int (&functions<2>::comm_find_owner)(types<2>::forest * p4est,
+ int (&functions<2>::comm_find_owner)(types<2>::forest *p4est,
const types<2>::locidx which_tree,
const types<2>::quadrant *q,
const int guess) =
types<2>::topidx num_vertices,
types<2>::topidx num_trees,
types<2>::topidx num_corners,
- const double * vertices,
+ const double *vertices,
const types<2>::topidx *ttv,
const types<2>::topidx *ttt,
- const int8_t * ttf,
+ const int8_t *ttf,
const types<2>::topidx *ttc,
const types<2>::topidx *coff,
const types<2>::topidx *ctt,
- const int8_t * ctc) = p4est_connectivity_new_copy;
+ const int8_t *ctc) = p4est_connectivity_new_copy;
void (&functions<2>::connectivity_join_faces)(types<2>::connectivity *conn,
types<2>::topidx tree_left,
int fill_uniform,
std::size_t data_size,
p4est_init_t init_fn,
- void * user_pointer) = p4est_new_ext;
+ void *user_pointer) = p4est_new_ext;
types<2>::forest *(&functions<2>::copy_forest)(types<2>::forest *input,
int copy_data) = p4est_copy;
p4est_coarsen_t coarsen_fn,
p4est_init_t init_fn) = p4est_coarsen;
- void (&functions<2>::balance)(types<2>::forest * p4est,
+ void (&functions<2>::balance)(types<2>::forest *p4est,
types<2>::balance_type btype,
p4est_init_t init_fn) = p4est_balance;
p4est_weight_t weight_fn) =
p4est_partition_ext;
- void (&functions<2>::save)(const char * filename,
+ void (&functions<2>::save)(const char *filename,
types<2>::forest *p4est,
int save_data) = p4est_save;
types<2>::forest *(&functions<2>::load_ext)(
- const char * filename,
+ const char *filename,
MPI_Comm mpicomm,
std::size_t data_size,
int load_data,
int autopartition,
int broadcasthead,
- void * user_pointer,
+ void *user_pointer,
types<2>::connectivity **p4est) = p4est_load_ext;
int (&functions<2>::connectivity_save)(
- const char * filename,
+ const char *filename,
types<2>::connectivity *connectivity) = p4est_connectivity_save;
int (&functions<2>::connectivity_is_valid)(
types<2>::connectivity *connectivity) = p4est_connectivity_is_valid;
types<2>::connectivity *(&functions<2>::connectivity_load)(
- const char * filename,
+ const char *filename,
std::size_t *length) = p4est_connectivity_load;
unsigned int (&functions<2>::checksum)(types<2>::forest *p4est) =
const char *baseName) =
p4est_vtk_write_file;
- types<2>::ghost *(&functions<2>::ghost_new)(types<2>::forest * p4est,
+ types<2>::ghost *(&functions<2>::ghost_new)(types<2>::forest *p4est,
types<2>::balance_type btype) =
p4est_ghost_new;
const types<2>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const void * src_data,
+ void *dest_data,
+ const void *src_data,
std::size_t data_size) =
p4est_transfer_fixed;
const types<2>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const void * src_data,
+ void *dest_data,
+ const void *src_data,
std::size_t data_size) = p4est_transfer_fixed_begin;
void (&functions<2>::transfer_fixed_end)(types<2>::transfer_context *tc) =
const types<2>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const int * dest_sizes,
- const void * src_data,
- const int * src_sizes) =
+ void *dest_data,
+ const int *dest_sizes,
+ const void *src_data,
+ const int *src_sizes) =
p4est_transfer_custom;
types<2>::transfer_context *(&functions<2>::transfer_custom_begin)(
const types<2>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const int * dest_sizes,
- const void * src_data,
- const int * src_sizes) = p4est_transfer_custom_begin;
+ void *dest_data,
+ const int *dest_sizes,
+ const void *src_data,
+ const int *src_sizes) = p4est_transfer_custom_begin;
void (&functions<2>::transfer_custom_end)(types<2>::transfer_context *tc) =
p4est_transfer_custom_end;
# ifdef P4EST_SEARCH_LOCAL
void (&functions<2>::search_partition)(
- types<2>::forest * p4est,
+ types<2>::forest *p4est,
int call_post,
types<2>::search_partition_callback quadrant_fn,
types<2>::search_partition_callback point_fn,
- sc_array_t * points) = p4est_search_partition;
+ sc_array_t *points) = p4est_search_partition;
# endif
void (&functions<2>::quadrant_coord_to_vertex)(
- types<2>::connectivity * connectivity,
+ types<2>::connectivity *connectivity,
types<2>::topidx treeid,
types<2>::quadrant_coord x,
types<2>::quadrant_coord y,
types<3>::quadrant c[]) =
p8est_quadrant_childrenv;
- int (&functions<3>::quadrant_overlaps_tree)(types<3>::tree * tree,
+ int (&functions<3>::quadrant_overlaps_tree)(types<3>::tree *tree,
const types<3>::quadrant *q) =
p8est_quadrant_overlaps_tree;
int level) =
p8est_quadrant_ancestor_id;
- int (&functions<3>::comm_find_owner)(types<3>::forest * p4est,
+ int (&functions<3>::comm_find_owner)(types<3>::forest *p4est,
const types<3>::locidx which_tree,
const types<3>::quadrant *q,
const int guess) =
types<3>::topidx num_trees,
types<3>::topidx num_edges,
types<3>::topidx num_corners,
- const double * vertices,
+ const double *vertices,
const types<3>::topidx *ttv,
const types<3>::topidx *ttt,
- const int8_t * ttf,
+ const int8_t *ttf,
const types<3>::topidx *tte,
const types<3>::topidx *eoff,
const types<3>::topidx *ett,
- const int8_t * ete,
+ const int8_t *ete,
const types<3>::topidx *ttc,
const types<3>::topidx *coff,
const types<3>::topidx *ctt,
- const int8_t * ctc) = p8est_connectivity_new_copy;
+ const int8_t *ctc) = p8est_connectivity_new_copy;
void (&functions<3>::connectivity_destroy)(
p8est_connectivity_t *connectivity) = p8est_connectivity_destroy;
int fill_uniform,
std::size_t data_size,
p8est_init_t init_fn,
- void * user_pointer) = p8est_new_ext;
+ void *user_pointer) = p8est_new_ext;
types<3>::forest *(&functions<3>::copy_forest)(types<3>::forest *input,
int copy_data) = p8est_copy;
p8est_coarsen_t coarsen_fn,
p8est_init_t init_fn) = p8est_coarsen;
- void (&functions<3>::balance)(types<3>::forest * p8est,
+ void (&functions<3>::balance)(types<3>::forest *p8est,
types<3>::balance_type btype,
p8est_init_t init_fn) = p8est_balance;
p8est_weight_t weight_fn) =
p8est_partition_ext;
- void (&functions<3>::save)(const char * filename,
+ void (&functions<3>::save)(const char *filename,
types<3>::forest *p4est,
int save_data) = p8est_save;
types<3>::forest *(&functions<3>::load_ext)(
- const char * filename,
+ const char *filename,
MPI_Comm mpicomm,
std::size_t data_size,
int load_data,
int autopartition,
int broadcasthead,
- void * user_pointer,
+ void *user_pointer,
types<3>::connectivity **p4est) = p8est_load_ext;
int (&functions<3>::connectivity_save)(
- const char * filename,
+ const char *filename,
types<3>::connectivity *connectivity) = p8est_connectivity_save;
int (&functions<3>::connectivity_is_valid)(
types<3>::connectivity *connectivity) = p8est_connectivity_is_valid;
types<3>::connectivity *(&functions<3>::connectivity_load)(
- const char * filename,
+ const char *filename,
std::size_t *length) = p8est_connectivity_load;
unsigned int (&functions<3>::checksum)(types<3>::forest *p8est) =
const char *baseName) =
p8est_vtk_write_file;
- types<3>::ghost *(&functions<3>::ghost_new)(types<3>::forest * p4est,
+ types<3>::ghost *(&functions<3>::ghost_new)(types<3>::forest *p4est,
types<3>::balance_type btype) =
p8est_ghost_new;
const types<3>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const void * src_data,
+ void *dest_data,
+ const void *src_data,
std::size_t data_size) =
p8est_transfer_fixed;
const types<3>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const void * src_data,
+ void *dest_data,
+ const void *src_data,
std::size_t data_size) = p8est_transfer_fixed_begin;
void (&functions<3>::transfer_fixed_end)(types<3>::transfer_context *tc) =
const types<3>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const int * dest_sizes,
- const void * src_data,
- const int * src_sizes) =
+ void *dest_data,
+ const int *dest_sizes,
+ const void *src_data,
+ const int *src_sizes) =
p8est_transfer_custom;
types<3>::transfer_context *(&functions<3>::transfer_custom_begin)(
const types<3>::gloidx *src_gfq,
MPI_Comm mpicomm,
int tag,
- void * dest_data,
- const int * dest_sizes,
- const void * src_data,
- const int * src_sizes) = p8est_transfer_custom_begin;
+ void *dest_data,
+ const int *dest_sizes,
+ const void *src_data,
+ const int *src_sizes) = p8est_transfer_custom_begin;
void (&functions<3>::transfer_custom_end)(types<3>::transfer_context *tc) =
p8est_transfer_custom_end;
# ifdef P4EST_SEARCH_LOCAL
void (&functions<3>::search_partition)(
- types<3>::forest * p4est,
+ types<3>::forest *p4est,
int call_post,
types<3>::search_partition_callback quadrant_fn,
types<3>::search_partition_callback point_fn,
- sc_array_t * points) = p8est_search_partition;
+ sc_array_t *points) = p8est_search_partition;
# endif
void (&functions<3>::quadrant_coord_to_vertex)(
- types<3>::connectivity * connectivity,
+ types<3>::connectivity *connectivity,
types<3>::topidx treeid,
types<3>::quadrant_coord x,
types<3>::quadrant_coord y,
void
add_indices_recursively_for_first_child_policy(
const TriaIterator<CellAccessor<dim, spacedim>> &cell,
- const internal::CellIDTranslator<dim> & cell_id_translator,
- IndexSet & is_fine)
+ const internal::CellIDTranslator<dim> &cell_id_translator,
+ IndexSet &is_fine)
{
is_fine.add_index(cell_id_translator.translate(cell));
unsigned int offset = 0;
- const int ierr = MPI_Exscan(&process_has_active_locally_owned_cells,
- &offset,
- 1,
- Utilities::MPI::mpi_type_id_for_type<decltype(
- process_has_active_locally_owned_cells)>,
- MPI_SUM,
- comm);
+ const int ierr =
+ MPI_Exscan(&process_has_active_locally_owned_cells,
+ &offset,
+ 1,
+ Utilities::MPI::mpi_type_id_for_type<
+ decltype(process_has_active_locally_owned_cells)>,
+ MPI_SUM,
+ comm);
AssertThrowMPI(ierr);
LinearAlgebra::distributed::Vector<double> partition(
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
void Triangulation<dim, spacedim>::create_triangulation(
const std::vector<Point<spacedim>> &vertices,
- const std::vector<CellData<dim>> & cells,
- const SubCellData & subcelldata)
+ const std::vector<CellData<dim>> &cells,
+ const SubCellData &subcelldata)
{
try
{
const typename Triangulation<dim, spacedim>::cell_iterator &cell_,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator>
- & data_range,
+ &data_range,
std::vector<VectorType *> &all_out,
- VectorType & valence)
+ VectorType &valence)
{
typename DoFHandler<dim, spacedim>::cell_iterator cell(*cell_,
dof_handler);
void
get_vertex_to_cell_mappings(
const Triangulation<dim, spacedim> &triangulation,
- std::vector<unsigned int> & vertex_touch_count,
+ std::vector<unsigned int> &vertex_touch_count,
std::vector<std::list<
std::pair<typename Triangulation<dim, spacedim>::active_cell_iterator,
- unsigned int>>> & vertex_to_cell)
+ unsigned int>>> &vertex_to_cell)
{
vertex_touch_count.resize(triangulation.n_vertices());
vertex_to_cell.resize(triangulation.n_vertices());
void
get_edge_to_cell_mappings(
const Triangulation<dim, spacedim> &triangulation,
- std::vector<unsigned int> & edge_touch_count,
+ std::vector<unsigned int> &edge_touch_count,
std::vector<std::list<
std::pair<typename Triangulation<dim, spacedim>::active_cell_iterator,
- unsigned int>>> & edge_to_cell)
+ unsigned int>>> &edge_to_cell)
{
Assert(triangulation.n_levels() == 1, ExcInternalError());
void
set_vertex_and_cell_info(
const Triangulation<dim, spacedim> &triangulation,
- const std::vector<unsigned int> & vertex_touch_count,
+ const std::vector<unsigned int> &vertex_touch_count,
const std::vector<std::list<
std::pair<typename Triangulation<dim, spacedim>::active_cell_iterator,
- unsigned int>>> & vertex_to_cell,
+ unsigned int>>> &vertex_to_cell,
const std::vector<types::global_dof_index>
- & coarse_cell_to_p4est_tree_permutation,
+ &coarse_cell_to_p4est_tree_permutation,
const bool set_vertex_info,
typename internal::p4est::types<dim>::connectivity *connectivity)
{
template <int dim, int spacedim>
void
determine_level_subdomain_id_recursively(
- const typename internal::p4est::types<dim>::tree & tree,
- const typename internal::p4est::types<dim>::locidx & tree_index,
+ const typename internal::p4est::types<dim>::tree &tree,
+ const typename internal::p4est::types<dim>::locidx &tree_index,
const typename Triangulation<dim, spacedim>::cell_iterator &dealii_cell,
- const typename internal::p4est::types<dim>::quadrant & p4est_cell,
- typename internal::p4est::types<dim>::forest & forest,
+ const typename internal::p4est::types<dim>::quadrant &p4est_cell,
+ typename internal::p4est::types<dim>::forest &forest,
const types::subdomain_id my_subdomain,
- const std::vector<std::vector<bool>> & marked_vertices)
+ const std::vector<std::vector<bool>> &marked_vertices)
{
if (dealii_cell->level_subdomain_id() == numbers::artificial_subdomain_id)
{
template <int dim, int spacedim>
void
match_tree_recursively(
- const typename internal::p4est::types<dim>::tree & tree,
+ const typename internal::p4est::types<dim>::tree &tree,
const typename Triangulation<dim, spacedim>::cell_iterator &dealii_cell,
- const typename internal::p4est::types<dim>::quadrant & p4est_cell,
- const typename internal::p4est::types<dim>::forest & forest,
+ const typename internal::p4est::types<dim>::quadrant &p4est_cell,
+ const typename internal::p4est::types<dim>::forest &forest,
const types::subdomain_id my_subdomain)
{
// check if this cell exists in the local p4est cell
template <int dim, int spacedim>
void
match_quadrant(
- const dealii::Triangulation<dim, spacedim> * tria,
+ const dealii::Triangulation<dim, spacedim> *tria,
unsigned int dealii_index,
const typename internal::p4est::types<dim>::quadrant &ghost_quadrant,
types::subdomain_id ghost_owner)
* does not belong to a quadrant.
*/
static int
- local_point_fn(typename internal::p4est::types<dim>::forest * forest,
+ local_point_fn(typename internal::p4est::types<dim>::forest *forest,
typename internal::p4est::types<dim>::topidx which_tree,
typename internal::p4est::types<dim>::quadrant *quadrant,
int rank_begin,
int rank_end,
- void * point);
+ void *point);
private:
/**
void
set_cell_vertices(
- typename internal::p4est::types<dim>::forest * forest,
+ typename internal::p4est::types<dim>::forest *forest,
typename internal::p4est::types<dim>::topidx which_tree,
typename internal::p4est::types<dim>::quadrant *quadrant,
const typename internal::p4est::types<dim>::quadrant_coord
template <int dim>
int
PartitionSearch<dim>::local_quadrant_fn(
- typename internal::p4est::types<dim>::forest * forest,
+ typename internal::p4est::types<dim>::forest *forest,
typename internal::p4est::types<dim>::topidx which_tree,
typename internal::p4est::types<dim>::quadrant *quadrant,
int /* rank_begin */,
template <>
void
PartitionSearch<2>::QuadrantData::set_cell_vertices(
- typename internal::p4est::types<2>::forest * forest,
+ typename internal::p4est::types<2>::forest *forest,
typename internal::p4est::types<2>::topidx which_tree,
typename internal::p4est::types<2>::quadrant *quadrant,
const typename internal::p4est::types<2>::quadrant_coord
template <>
void
PartitionSearch<3>::QuadrantData::set_cell_vertices(
- typename internal::p4est::types<3>::forest * forest,
+ typename internal::p4est::types<3>::forest *forest,
typename internal::p4est::types<3>::topidx which_tree,
typename internal::p4est::types<3>::quadrant *quadrant,
const typename internal::p4est::types<3>::quadrant_coord
*/
static int
refine_callback(
- typename internal::p4est::types<dim>::forest * forest,
+ typename internal::p4est::types<dim>::forest *forest,
typename internal::p4est::types<dim>::topidx coarse_cell_index,
typename internal::p4est::types<dim>::quadrant *quadrant);
*/
static int
coarsen_callback(
- typename internal::p4est::types<dim>::forest * forest,
+ typename internal::p4est::types<dim>::forest *forest,
typename internal::p4est::types<dim>::topidx coarse_cell_index,
typename internal::p4est::types<dim>::quadrant *children[]);
void
build_lists(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const typename internal::p4est::types<dim>::quadrant & p4est_cell,
+ const typename internal::p4est::types<dim>::quadrant &p4est_cell,
const types::subdomain_id myid);
};
RefineAndCoarsenList<dim, spacedim>::RefineAndCoarsenList(
const Triangulation<dim, spacedim> &triangulation,
const std::vector<types::global_dof_index>
- & p4est_tree_to_coarse_cell_permutation,
+ &p4est_tree_to_coarse_cell_permutation,
const types::subdomain_id my_subdomain)
{
// count how many flags are set and allocate that much memory
void
RefineAndCoarsenList<dim, spacedim>::build_lists(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const typename internal::p4est::types<dim>::quadrant & p4est_cell,
+ const typename internal::p4est::types<dim>::quadrant &p4est_cell,
const types::subdomain_id my_subdomain)
{
if (cell->is_active())
template <int dim, int spacedim>
int
RefineAndCoarsenList<dim, spacedim>::refine_callback(
- typename internal::p4est::types<dim>::forest * forest,
+ typename internal::p4est::types<dim>::forest *forest,
typename internal::p4est::types<dim>::topidx coarse_cell_index,
typename internal::p4est::types<dim>::quadrant *quadrant)
{
template <int dim, int spacedim>
int
RefineAndCoarsenList<dim, spacedim>::coarsen_callback(
- typename internal::p4est::types<dim>::forest * forest,
+ typename internal::p4est::types<dim>::forest *forest,
typename internal::p4est::types<dim>::topidx coarse_cell_index,
typename internal::p4est::types<dim>::quadrant *children[])
{
template <int dim, int spacedim>
inline void
add_single_cell_relation(
- std::vector<cell_relation_t<dim, spacedim>> & cell_rel,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
+ std::vector<cell_relation_t<dim, spacedim>> &cell_rel,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
const unsigned int idx,
const typename Triangulation<dim, spacedim>::cell_iterator &dealii_cell,
const CellStatus status)
template <int dim, int spacedim>
void
update_cell_relations_recursively(
- std::vector<cell_relation_t<dim, spacedim>> & cell_rel,
- const typename dealii::internal::p4est::types<dim>::tree & tree,
- const typename Triangulation<dim, spacedim>::cell_iterator & dealii_cell,
+ std::vector<cell_relation_t<dim, spacedim>> &cell_rel,
+ const typename dealii::internal::p4est::types<dim>::tree &tree,
+ const typename Triangulation<dim, spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant &p4est_cell)
{
// find index of p4est_cell in the quadrants array of the corresponding tree
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
void Triangulation<dim, spacedim>::create_triangulation(
const std::vector<Point<spacedim>> &vertices,
- const std::vector<CellData<dim>> & cells,
- const SubCellData & subcelldata)
+ const std::vector<CellData<dim>> &cells,
+ const SubCellData &subcelldata)
{
try
{
# ifndef DOXYGEN
template <>
- void Triangulation<2, 2>::copy_new_triangulation_to_p4est(
+ void
+ Triangulation<2, 2>::copy_new_triangulation_to_p4est(
std::integral_constant<int, 2>)
{
const unsigned int dim = 2, spacedim = 2;
// TODO: This is a verbatim copy of the 2,2 case. However, we can't just
// specialize the dim template argument, but let spacedim open
template <>
- void Triangulation<2, 3>::copy_new_triangulation_to_p4est(
+ void
+ Triangulation<2, 3>::copy_new_triangulation_to_p4est(
std::integral_constant<int, 2>)
{
const unsigned int dim = 2, spacedim = 3;
template <>
- void Triangulation<3, 3>::copy_new_triangulation_to_p4est(
+ void
+ Triangulation<3, 3>::copy_new_triangulation_to_p4est(
std::integral_constant<int, 3>)
{
const int dim = 3, spacedim = 3;
for (unsigned int repetition = 0; repetition < dim; ++repetition)
for (const auto &it : this->get_periodic_face_map())
{
- const cell_iterator & cell_1 = it.first.first;
+ const cell_iterator &cell_1 = it.first.first;
const unsigned int face_no_1 = it.first.second;
- const cell_iterator & cell_2 = it.second.first.first;
+ const cell_iterator &cell_2 = it.second.first.first;
const unsigned int face_no_2 = it.second.first.second;
const std::bitset<3> &face_orientation = it.second.second;
Assert(dof.has_hp_capabilities() == false,
(typename DoFHandler<dim, spacedim>::ExcNotImplementedWithHP()));
- const FiniteElement<dim, spacedim> & fe = dof.get_fe();
+ const FiniteElement<dim, spacedim> &fe = dof.get_fe();
std::vector<types::global_dof_index> sizes(fe.n_blocks());
base_elements.resize(fe.n_blocks());
void
DoFCellAccessor<dim, spacedim, lda>::get_interpolated_dof_values(
const ReadVector<Number> &values,
- Vector<Number> & interpolated_values,
+ Vector<Number> &interpolated_values,
const types::fe_index fe_index_) const
{
const types::fe_index fe_index =
typename number>
void
set_dof_values(const DoFCellAccessor<dim, spacedim, lda> &cell,
- const Vector<number> & local_values,
- OutputVector & values,
+ const Vector<number> &local_values,
+ OutputVector &values,
const bool perform_check)
{
(void)perform_check;
typename number>
void
process_by_interpolation(
- const DoFCellAccessor<dim, spacedim, lda> & cell,
- const Vector<number> & local_values,
- OutputVector & values,
+ const DoFCellAccessor<dim, spacedim, lda> &cell,
+ const Vector<number> &local_values,
+ OutputVector &values,
const types::fe_index fe_index_,
const std::function<void(const DoFCellAccessor<dim, spacedim, lda> &cell,
const Vector<number> &local_values,
- OutputVector & values)> &processor)
+ OutputVector &values)> &processor)
{
const types::fe_index fe_index =
(cell.get_dof_handler().has_hp_capabilities() == false &&
void
DoFCellAccessor<dim, spacedim, lda>::set_dof_values_by_interpolation(
const Vector<number> &local_values,
- OutputVector & values,
+ OutputVector &values,
const types::fe_index fe_index_,
const bool perform_check) const
{
values,
fe_index_,
[perform_check](const DoFCellAccessor<dim, spacedim, lda> &cell,
- const Vector<number> & local_values,
- OutputVector & values) {
+ const Vector<number> &local_values,
+ OutputVector &values) {
internal::set_dof_values(cell, local_values, values, perform_check);
});
}
DoFCellAccessor<dim, spacedim, lda>::
distribute_local_to_global_by_interpolation(
const Vector<number> &local_values,
- OutputVector & values,
+ OutputVector &values,
const types::fe_index fe_index_) const
{
internal::process_by_interpolation<dim, spacedim, lda, OutputVector, number>(
values,
fe_index_,
[](const DoFCellAccessor<dim, spacedim, lda> &cell,
- const Vector<number> & local_values,
- OutputVector & values) {
+ const Vector<number> &local_values,
+ OutputVector &values) {
std::vector<types::global_dof_index> dof_indices(
cell.get_fe().n_dofs_per_cell());
cell.get_dof_indices(dof_indices);
reserve_subentities(DoFHandler<dim, spacedim> &dof_handler,
const unsigned int structdim,
const unsigned int n_raw_entities,
- const T & cell_process)
+ const T &cell_process)
{
if (dof_handler.tria->n_cells() == 0)
return;
auto unpack =
[&dof_handler](
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & cell,
+ &cell,
const types::fe_index active_fe_index) -> void {
// we would like to say
// cell->set_active_fe_index(active_fe_index);
auto unpack =
[&dof_handler](
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & cell,
+ &cell,
const types::fe_index future_fe_index) -> void {
dof_handler
.hp_cell_future_fe_indices[cell->level()][cell->index()] =
static types::fe_index
determine_fe_from_children(
const typename Triangulation<dim, spacedim>::cell_iterator &,
- const std::vector<types::fe_index> & children_fe_indices,
+ const std::vector<types::fe_index> &children_fe_indices,
const dealii::hp::FECollection<dim, spacedim> &fe_collection)
{
Assert(!children_fe_indices.empty(), ExcInternalError());
const dealii::hp::FECollection<dim, spacedim> &fes,
const types::fe_index fe_index_1,
const types::fe_index fe_index_2,
- std::unique_ptr<DoFIdentities> & identities,
+ std::unique_ptr<DoFIdentities> &identities,
const unsigned int face_no = numbers::invalid_unsigned_int)
{
Assert(structdim == 2 || face_no == numbers::invalid_unsigned_int,
std::vector<types::global_dof_index> &new_dof_indices,
const std::vector<
std::map<types::global_dof_index, types::global_dof_index>>
- & all_constrained_indices,
+ &all_constrained_indices,
const types::global_dof_index start_dof_index)
{
// first preset the new DoF indices that are identities
invalidate_dof_indices_on_weaker_ghost_cells_for_renumbering(
std::vector<types::global_dof_index> &renumbering,
const types::subdomain_id subdomain_id,
- const DoFHandler<dim, spacedim> & dof_handler)
+ const DoFHandler<dim, spacedim> &dof_handler)
{
std::vector<types::global_dof_index> local_dof_indices;
static void
renumber_face_dofs(
const std::vector<types::global_dof_index> &new_numbers,
- const IndexSet & indices_we_care_about,
- DoFHandler<dim, spacedim> & dof_handler)
+ const IndexSet &indices_we_care_about,
+ DoFHandler<dim, spacedim> &dof_handler)
{
for (unsigned int d = 1; d < dim; ++d)
for (auto &i : dof_handler.object_dof_indices[0][d])
static void
renumber_vertex_dofs(
const std::vector<types::global_dof_index> &new_numbers,
- const IndexSet & indices_we_care_about,
- DoFHandler<dim, spacedim> & dof_handler,
+ const IndexSet &indices_we_care_about,
+ DoFHandler<dim, spacedim> &dof_handler,
const bool check_validity)
{
if (dof_handler.hp_capability_enabled == false)
static void
renumber_cell_dofs(
const std::vector<types::global_dof_index> &new_numbers,
- const IndexSet & indices_we_care_about,
- DoFHandler<dim, spacedim> & dof_handler)
+ const IndexSet &indices_we_care_about,
+ DoFHandler<dim, spacedim> &dof_handler)
{
if (dof_handler.hp_capability_enabled == false)
{
static void
renumber_face_dofs(
const std::vector<types::global_dof_index> &new_numbers,
- const IndexSet & indices_we_care_about,
- DoFHandler<2, spacedim> & dof_handler)
+ const IndexSet &indices_we_care_about,
+ DoFHandler<2, spacedim> &dof_handler)
{
const unsigned int dim = 2;
static void
renumber_face_dofs(
const std::vector<types::global_dof_index> &new_numbers,
- const IndexSet & indices_we_care_about,
- DoFHandler<3, spacedim> & dof_handler)
+ const IndexSet &indices_we_care_about,
+ DoFHandler<3, spacedim> &dof_handler)
{
const unsigned int dim = 3;
template <int dim, int space_dim>
static void
renumber_dofs(const std::vector<types::global_dof_index> &new_numbers,
- const IndexSet & indices_we_care_about,
+ const IndexSet &indices_we_care_about,
const DoFHandler<dim, space_dim> &dof_handler,
const bool check_validity)
{
static void
renumber_vertex_mg_dofs(
const std::vector<dealii::types::global_dof_index> &new_numbers,
- const IndexSet & indices_we_care_about,
+ const IndexSet &indices_we_care_about,
DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level)
{
static void
renumber_cell_mg_dofs(
const std::vector<dealii::types::global_dof_index> &new_numbers,
- const IndexSet & indices_we_care_about,
+ const IndexSet &indices_we_care_about,
DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level)
{
static void
renumber_face_mg_dofs(
const std::vector<dealii::types::global_dof_index> &new_numbers,
- const IndexSet & indices_we_care_about,
+ const IndexSet &indices_we_care_about,
DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const bool check_validity)
static void
renumber_mg_dofs(
const std::vector<dealii::types::global_dof_index> &new_numbers,
- const IndexSet & indices_we_care_about,
+ const IndexSet &indices_we_care_about,
DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const bool check_validity)
{
template <int dim, int spacedim>
void
- communicate_mg_ghost_cells(DoFHandler<dim, spacedim> & dof_handler,
+ communicate_mg_ghost_cells(DoFHandler<dim, spacedim> &dof_handler,
std::vector<std::vector<bool>> &cell_marked)
{
const auto pack = [](const auto &cell) {
void
communicate_dof_indices_on_marked_cells(
const DoFHandler<dim, spacedim> &dof_handler,
- std::vector<bool> & cell_marked)
+ std::vector<bool> &cell_marked)
{
# ifndef DEAL_II_WITH_MPI
(void)dof_handler;
void
create_graph(const DoFHandler<dim, spacedim> &dof_handler,
const bool use_constraints,
- boosttypes::Graph & graph,
+ boosttypes::Graph &graph,
boosttypes::property_map<boosttypes::Graph,
boosttypes::vertex_degree_t>::type
&graph_degree)
template <int dim, int spacedim>
void
compute_Cuthill_McKee(std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const bool reversed_numbering,
const bool use_constraints)
{
template <int dim, int spacedim>
void
compute_king_ordering(std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const bool reversed_numbering,
const bool use_constraints)
{
void
compute_minimum_degree(
std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const bool reversed_numbering,
const bool use_constraints)
{
template <int dim, int spacedim>
void
- Cuthill_McKee(DoFHandler<dim, spacedim> & dof_handler,
+ Cuthill_McKee(DoFHandler<dim, spacedim> &dof_handler,
const bool reversed_numbering,
const bool use_constraints,
const std::vector<types::global_dof_index> &starting_indices)
template <int dim, int spacedim>
void
compute_Cuthill_McKee(
- std::vector<types::global_dof_index> & new_indices,
- const DoFHandler<dim, spacedim> & dof_handler,
+ std::vector<types::global_dof_index> &new_indices,
+ const DoFHandler<dim, spacedim> &dof_handler,
const bool reversed_numbering,
const bool use_constraints,
const std::vector<types::global_dof_index> &starting_indices,
template <int dim, int spacedim>
void
- Cuthill_McKee(DoFHandler<dim, spacedim> & dof_handler,
+ Cuthill_McKee(DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const bool reversed_numbering,
const std::vector<types::global_dof_index> &starting_indices)
template <int dim, int spacedim>
void
- component_wise(DoFHandler<dim, spacedim> & dof_handler,
+ component_wise(DoFHandler<dim, spacedim> &dof_handler,
const std::vector<unsigned int> &component_order_arg)
{
std::vector<types::global_dof_index> renumbering(
template <int dim, int spacedim>
void
- component_wise(DoFHandler<dim, spacedim> & dof_handler,
+ component_wise(DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const std::vector<unsigned int> &component_order_arg)
{
template <int dim, int spacedim, typename CellIterator>
types::global_dof_index
compute_component_wise(std::vector<types::global_dof_index> &new_indices,
- const CellIterator & start,
+ const CellIterator &start,
const std_cxx20::type_identity_t<CellIterator> &end,
const std::vector<unsigned int> &component_order_arg,
const bool is_level_operation)
template <int dim, int spacedim, class ITERATOR, class ENDITERATOR>
types::global_dof_index
compute_block_wise(std::vector<types::global_dof_index> &new_indices,
- const ITERATOR & start,
- const ENDITERATOR & end,
+ const ITERATOR &start,
+ const ENDITERATOR &end,
const bool is_level_operation)
{
const hp::FECollection<dim, spacedim> &fe_collection =
compute_hierarchical_recursive(
const types::global_dof_index next_free_dof_offset,
const types::global_dof_index my_starting_index,
- const CellIteratorType & cell,
- const IndexSet & locally_owned_dof_indices,
+ const CellIteratorType &cell,
+ const IndexSet &locally_owned_dof_indices,
std::vector<types::global_dof_index> &new_indices)
{
types::global_dof_index current_next_free_dof_offset =
template <int dim, int spacedim>
void
sort_selected_dofs_back(DoFHandler<dim, spacedim> &dof_handler,
- const std::vector<bool> & selected_dofs)
+ const std::vector<bool> &selected_dofs)
{
std::vector<types::global_dof_index> renumbering(
dof_handler.n_dofs(), numbers::invalid_dof_index);
template <int dim, int spacedim>
void
sort_selected_dofs_back(DoFHandler<dim, spacedim> &dof_handler,
- const std::vector<bool> & selected_dofs,
+ const std::vector<bool> &selected_dofs,
const unsigned int level)
{
Assert(dof_handler.n_dofs(level) != numbers::invalid_dof_index,
void
compute_sort_selected_dofs_back(
std::vector<types::global_dof_index> &new_indices,
- const DoFHandler<dim, spacedim> & dof_handler,
- const std::vector<bool> & selected_dofs)
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const std::vector<bool> &selected_dofs)
{
const types::global_dof_index n_dofs = dof_handler.n_dofs();
Assert(selected_dofs.size() == n_dofs,
void
compute_sort_selected_dofs_back(
std::vector<types::global_dof_index> &new_indices,
- const DoFHandler<dim, spacedim> & dof_handler,
- const std::vector<bool> & selected_dofs,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const std::vector<bool> &selected_dofs,
const unsigned int level)
{
Assert(dof_handler.n_dofs(level) != numbers::invalid_dof_index,
compute_cell_wise(
std::vector<types::global_dof_index> &new_indices,
std::vector<types::global_dof_index> &reverse,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const typename std::vector<
typename DoFHandler<dim, spacedim>::active_cell_iterator> &cells)
{
compute_cell_wise(
std::vector<types::global_dof_index> &new_order,
std::vector<types::global_dof_index> &reverse,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const unsigned int level,
const typename std::vector<
typename DoFHandler<dim, spacedim>::level_cell_iterator> &cells)
void
compute_downstream(std::vector<types::global_dof_index> &new_indices,
std::vector<types::global_dof_index> &reverse,
- const DoFHandler<dim, spacedim> & dof,
- const Tensor<1, spacedim> & direction,
+ const DoFHandler<dim, spacedim> &dof,
+ const Tensor<1, spacedim> &direction,
const bool dof_wise_renumbering)
{
Assert((dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
void
compute_downstream(std::vector<types::global_dof_index> &new_indices,
std::vector<types::global_dof_index> &reverse,
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const unsigned int level,
- const Tensor<1, spacedim> & direction,
+ const Tensor<1, spacedim> &direction,
const bool dof_wise_renumbering)
{
if (dof_wise_renumbering == false)
template <int dim, int spacedim>
void
clockwise_dg(DoFHandler<dim, spacedim> &dof,
- const Point<spacedim> & center,
+ const Point<spacedim> ¢er,
const bool counter)
{
std::vector<types::global_dof_index> renumbering(dof.n_dofs());
template <int dim, int spacedim>
void
compute_clockwise_dg(std::vector<types::global_dof_index> &new_indices,
- const DoFHandler<dim, spacedim> & dof,
- const Point<spacedim> & center,
+ const DoFHandler<dim, spacedim> &dof,
+ const Point<spacedim> ¢er,
const bool counter)
{
std::vector<typename DoFHandler<dim, spacedim>::active_cell_iterator>
void
clockwise_dg(DoFHandler<dim, spacedim> &dof,
const unsigned int level,
- const Point<spacedim> & center,
+ const Point<spacedim> ¢er,
const bool counter)
{
std::vector<typename DoFHandler<dim, spacedim>::level_cell_iterator>
template <int dim, int spacedim>
void
compute_random(std::vector<types::global_dof_index> &new_indices,
- const DoFHandler<dim, spacedim> & dof_handler)
+ const DoFHandler<dim, spacedim> &dof_handler)
{
const types::global_dof_index n_dofs = dof_handler.n_dofs();
Assert(new_indices.size() == n_dofs,
template <int dim, int spacedim>
void
compute_random(std::vector<types::global_dof_index> &new_indices,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level)
{
const types::global_dof_index n_dofs = dof_handler.n_dofs(level);
template <int dim, int spacedim>
void
compute_subdomain_wise(std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler)
+ const DoFHandler<dim, spacedim> &dof_handler)
{
const types::global_dof_index n_dofs = dof_handler.n_dofs();
Assert(new_dof_indices.size() == n_dofs,
void
compute_support_point_wise(
std::vector<types::global_dof_index> &new_dof_indices,
- const DoFHandler<dim, spacedim> & dof_handler)
+ const DoFHandler<dim, spacedim> &dof_handler)
{
const types::global_dof_index n_dofs = dof_handler.n_locally_owned_dofs();
Assert(new_dof_indices.size() == n_dofs,
typename VectorizedArrayType>
void
matrix_free_data_locality(
- DoFHandler<dim, spacedim> & dof_handler,
+ DoFHandler<dim, spacedim> &dof_handler,
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free)
{
const std::vector<types::global_dof_index> new_global_numbers =
template <int dim, int spacedim, typename Number, typename AdditionalDataType>
void
- matrix_free_data_locality(DoFHandler<dim, spacedim> & dof_handler,
+ matrix_free_data_locality(DoFHandler<dim, spacedim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const AdditionalDataType & matrix_free_data)
+ const AdditionalDataType &matrix_free_data)
{
const std::vector<types::global_dof_index> new_global_numbers =
compute_matrix_free_data_locality(dof_handler,
compute_matrix_free_data_locality(
const DoFHandler<dim, spacedim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const AdditionalDataType & matrix_free_data)
+ const AdditionalDataType &matrix_free_data)
{
AdditionalDataType my_mf_data = matrix_free_data;
my_mf_data.initialize_mapping = false;
}
const auto renumber_func = [](const types::global_dof_index dof_index,
- const IndexSet & owned_dofs,
- std::vector<unsigned int> & result,
+ const IndexSet &owned_dofs,
+ std::vector<unsigned int> &result,
unsigned int &counter_dof_numbers) {
const types::global_dof_index local_dof_index =
owned_dofs.index_within_set(dof_index);
typename VectorizedArrayType>
std::vector<types::global_dof_index>
compute_matrix_free_data_locality(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free)
{
Assert(matrix_free.indices_initialized(),
template <int dim, int spacedim>
void
get_component_association(const DoFHandler<dim, spacedim> &dof,
- const ComponentMask & component_mask,
+ const ComponentMask &component_mask,
std::vector<unsigned char> &dofs_by_component)
{
const dealii::hp::FECollection<dim, spacedim> &fe_collection =
template <int dim, int spacedim>
inline void
get_block_association(const DoFHandler<dim, spacedim> &dof,
- std::vector<unsigned char> & dofs_by_block)
+ std::vector<unsigned char> &dofs_by_block)
{
const dealii::hp::FECollection<dim, spacedim> &fe_collection =
dof.get_fe_collection();
template <int dim, int spacedim, typename Number>
void
distribute_cell_to_dof_vector(const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & cell_data,
- Vector<double> & dof_data,
+ const Vector<Number> &cell_data,
+ Vector<double> &dof_data,
const unsigned int component)
{
const Triangulation<dim, spacedim> &tria = dof_handler.get_triangulation();
template <int dim, int spacedim>
IndexSet
extract_dofs(const DoFHandler<dim, spacedim> &dof,
- const ComponentMask & component_mask)
+ const ComponentMask &component_mask)
{
Assert(component_mask.represents_n_components(
dof.get_fe_collection().n_components()),
template <int dim, int spacedim>
IndexSet
extract_dofs(const DoFHandler<dim, spacedim> &dof,
- const BlockMask & block_mask)
+ const BlockMask &block_mask)
{
// simply forward to the function that works based on a component mask
return extract_dofs<dim, spacedim>(
void
extract_level_dofs(const unsigned int level,
const DoFHandler<dim, spacedim> &dof,
- const ComponentMask & component_mask,
- std::vector<bool> & selected_dofs)
+ const ComponentMask &component_mask,
+ std::vector<bool> &selected_dofs)
{
const FiniteElement<dim, spacedim> &fe = dof.get_fe();
void
extract_level_dofs(const unsigned int level,
const DoFHandler<dim, spacedim> &dof,
- const BlockMask & block_mask,
- std::vector<bool> & selected_dofs)
+ const BlockMask &block_mask,
+ std::vector<bool> &selected_dofs)
{
// simply defer to the other extract_level_dofs() function
extract_level_dofs(level,
template <int dim, int spacedim>
void
- extract_boundary_dofs(const DoFHandler<dim, spacedim> & dof_handler,
- const ComponentMask & component_mask,
- std::vector<bool> & selected_dofs,
+ extract_boundary_dofs(const DoFHandler<dim, spacedim> &dof_handler,
+ const ComponentMask &component_mask,
+ std::vector<bool> &selected_dofs,
const std::set<types::boundary_id> &boundary_ids)
{
Assert((dynamic_cast<
template <int dim, int spacedim>
void
- extract_boundary_dofs(const DoFHandler<dim, spacedim> & dof_handler,
- const ComponentMask & component_mask,
- IndexSet & selected_dofs,
+ extract_boundary_dofs(const DoFHandler<dim, spacedim> &dof_handler,
+ const ComponentMask &component_mask,
+ IndexSet &selected_dofs,
const std::set<types::boundary_id> &boundary_ids)
{
// Simply forward to the other function
template <int dim, int spacedim>
IndexSet
- extract_boundary_dofs(const DoFHandler<dim, spacedim> & dof_handler,
- const ComponentMask & component_mask,
+ extract_boundary_dofs(const DoFHandler<dim, spacedim> &dof_handler,
+ const ComponentMask &component_mask,
const std::set<types::boundary_id> &boundary_ids)
{
Assert(component_mask.represents_n_components(
template <int dim, int spacedim>
void
extract_dofs_with_support_on_boundary(
- const DoFHandler<dim, spacedim> & dof_handler,
- const ComponentMask & component_mask,
- std::vector<bool> & selected_dofs,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const ComponentMask &component_mask,
+ std::vector<bool> &selected_dofs,
const std::set<types::boundary_id> &boundary_ids)
{
Assert(component_mask.represents_n_components(
const DoFHandler<dim, spacedim> &dof_handler,
const std::function<
bool(const typename DoFHandler<dim, spacedim>::active_cell_iterator &)>
- & predicate,
+ &predicate,
const AffineConstraints<number> &cm)
{
const std::function<bool(
void
extract_subdomain_dofs(const DoFHandler<dim, spacedim> &dof_handler,
const types::subdomain_id subdomain_id,
- std::vector<bool> & selected_dofs)
+ std::vector<bool> &selected_dofs)
{
Assert(selected_dofs.size() == dof_handler.n_dofs(),
ExcDimensionMismatch(selected_dofs.size(), dof_handler.n_dofs()));
template <int dim, int spacedim>
void
extract_locally_active_dofs(const DoFHandler<dim, spacedim> &dof_handler,
- IndexSet & dof_set)
+ IndexSet &dof_set)
{
dof_set = extract_locally_active_dofs(dof_handler);
}
void
extract_locally_active_level_dofs(
const DoFHandler<dim, spacedim> &dof_handler,
- IndexSet & dof_set,
+ IndexSet &dof_set,
const unsigned int level)
{
dof_set = extract_locally_active_level_dofs(dof_handler, level);
template <int dim, int spacedim>
void
extract_locally_relevant_dofs(const DoFHandler<dim, spacedim> &dof_handler,
- IndexSet & dof_set)
+ IndexSet &dof_set)
{
dof_set = extract_locally_relevant_dofs(dof_handler);
}
extract_locally_relevant_level_dofs(
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
- IndexSet & dof_set)
+ IndexSet &dof_set)
{
dof_set = extract_locally_relevant_level_dofs(dof_handler, level);
}
template <int dim, int spacedim>
void
extract_constant_modes(const DoFHandler<dim, spacedim> &dof_handler,
- const ComponentMask & component_mask,
- std::vector<std::vector<bool>> & constant_modes)
+ const ComponentMask &component_mask,
+ std::vector<std::vector<bool>> &constant_modes)
{
// If there are no locally owned DoFs, return with an empty
// constant_modes object:
map_boundary_to_bulk_dof_iterators(
const std::map<typename Triangulation<dim - 1, spacedim>::cell_iterator,
typename Triangulation<dim, spacedim>::face_iterator>
- & c1_to_c0_face,
- const DoFHandler<dim, spacedim> & c0_dh,
+ &c1_to_c0_face,
+ const DoFHandler<dim, spacedim> &c0_dh,
const DoFHandler<dim - 1, spacedim> &c1_dh)
{
// This is the returned object: a map of codimension-1 active dof cell
template <int dim, int spacedim>
void
get_active_fe_indices(const DoFHandler<dim, spacedim> &dof_handler,
- std::vector<unsigned int> & active_fe_indices)
+ std::vector<unsigned int> &active_fe_indices)
{
AssertDimension(active_fe_indices.size(),
dof_handler.get_triangulation().n_active_cells());
template <int dim, int spacedim>
void
get_subdomain_association(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
std::vector<types::subdomain_id> &subdomain_association)
{
// if the Triangulation is distributed, the only thing we can usefully
count_dofs_with_subdomain_association(
const DoFHandler<dim, spacedim> &dof_handler,
const types::subdomain_id subdomain,
- std::vector<unsigned int> & n_dofs_on_subdomain)
+ std::vector<unsigned int> &n_dofs_on_subdomain)
{
Assert(n_dofs_on_subdomain.size() == dof_handler.get_fe(0).n_components(),
ExcDimensionMismatch(n_dofs_on_subdomain.size(),
// index
template <int dim, int spacedim>
void
- resolve_components(const FiniteElement<dim, spacedim> & fe,
- const std::vector<unsigned char> & dofs_by_component,
- const std::vector<unsigned int> & target_component,
+ resolve_components(const FiniteElement<dim, spacedim> &fe,
+ const std::vector<unsigned char> &dofs_by_component,
+ const std::vector<unsigned int> &target_component,
const bool only_once,
std::vector<types::global_dof_index> &dofs_per_component,
- unsigned int & component)
+ unsigned int &component)
{
for (unsigned int b = 0; b < fe.n_base_elements(); ++b)
{
template <int dim, int spacedim>
void
resolve_components(const hp::FECollection<dim, spacedim> &fe_collection,
- const std::vector<unsigned char> & dofs_by_component,
- const std::vector<unsigned int> & target_component,
+ const std::vector<unsigned char> &dofs_by_component,
+ const std::vector<unsigned int> &target_component,
const bool only_once,
std::vector<types::global_dof_index> &dofs_per_component,
- unsigned int & component)
+ unsigned int &component)
{
// assert that all elements in the collection have the same structure
// (base elements and multiplicity, components per base element) and
template <int dim, int spacedim>
void
- map_dof_to_boundary_indices(const DoFHandler<dim, spacedim> & dof_handler,
+ map_dof_to_boundary_indices(const DoFHandler<dim, spacedim> &dof_handler,
std::vector<types::global_dof_index> &mapping)
{
mapping.clear();
template <int dim, int spacedim>
void
- map_dof_to_boundary_indices(const DoFHandler<dim, spacedim> & dof_handler,
+ map_dof_to_boundary_indices(const DoFHandler<dim, spacedim> &dof_handler,
const std::set<types::boundary_id> &boundary_ids,
std::vector<types::global_dof_index> &mapping)
{
std::map<types::global_dof_index, Point<spacedim>>
map_dofs_to_support_points(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const ComponentMask & in_mask)
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const ComponentMask &in_mask)
{
std::map<types::global_dof_index, Point<spacedim>> support_points;
std::vector<Point<spacedim>>
map_dofs_to_support_points_vector(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const ComponentMask & mask)
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const ComponentMask &mask)
{
std::vector<Point<spacedim>> support_points(dof_handler.n_dofs());
template <int dim, int spacedim>
void
- map_dofs_to_support_points(const Mapping<dim, spacedim> & mapping,
+ map_dofs_to_support_points(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- std::vector<Point<spacedim>> & support_points,
- const ComponentMask & mask)
+ std::vector<Point<spacedim>> &support_points,
+ const ComponentMask &mask)
{
AssertDimension(support_points.size(), dof_handler.n_dofs());
Assert((dynamic_cast<
void
map_dofs_to_support_points(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- std::vector<Point<spacedim>> & support_points,
- const ComponentMask & mask)
+ const DoFHandler<dim, spacedim> &dof_handler,
+ std::vector<Point<spacedim>> &support_points,
+ const ComponentMask &mask)
{
AssertDimension(support_points.size(), dof_handler.n_dofs());
Assert((dynamic_cast<
template <int dim, int spacedim>
DEAL_II_DEPRECATED void
map_dofs_to_support_points(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
std::map<types::global_dof_index, Point<spacedim>> &support_points,
- const ComponentMask & mask)
+ const ComponentMask &mask)
{
support_points.clear();
template <int dim, int spacedim>
DEAL_II_DEPRECATED void
map_dofs_to_support_points(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
std::map<types::global_dof_index, Point<spacedim>> &support_points,
- const ComponentMask & mask)
+ const ComponentMask &mask)
{
support_points.clear();
template <int dim, int spacedim>
std::map<types::global_dof_index, Point<spacedim>>
- map_dofs_to_support_points(const Mapping<dim, spacedim> & mapping,
+ map_dofs_to_support_points(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const ComponentMask & mask)
+ const ComponentMask &mask)
{
// Let the internal function do all the work, just make sure that it
// gets a MappingCollection
std::map<types::global_dof_index, Point<spacedim>>
map_dofs_to_support_points(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const ComponentMask & mask)
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const ComponentMask &mask)
{
return internal::map_dofs_to_support_points(mapping, dof_handler, mask);
}
template <int spacedim>
void
write_gnuplot_dof_support_point_info(
- std::ostream & out,
+ std::ostream &out,
const std::map<types::global_dof_index, Point<spacedim>> &support_points)
{
AssertThrow(out.fail() == false, ExcIO());
template <int dim, int spacedim>
void
convert_couplings_to_blocks(const DoFHandler<dim, spacedim> &dof_handler,
- const Table<2, Coupling> & table,
+ const Table<2, Coupling> &table,
std::vector<Table<2, Coupling>> &tables_by_block)
{
if (dof_handler.has_hp_capabilities() == false)
template <int dim, int spacedim>
void
- make_cell_patches(SparsityPattern & block_list,
+ make_cell_patches(SparsityPattern &block_list,
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
- const std::vector<bool> & selected_dofs,
+ const std::vector<bool> &selected_dofs,
const types::global_dof_index offset)
{
std::vector<types::global_dof_index> indices;
template <int dim, int spacedim>
void
- make_single_patch(SparsityPattern & block_list,
+ make_single_patch(SparsityPattern &block_list,
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const bool interior_only)
template <int dim, int spacedim>
void
- make_child_patches(SparsityPattern & block_list,
+ make_child_patches(SparsityPattern &block_list,
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const bool interior_dofs_only,
template <int dim, int spacedim>
std::vector<unsigned int>
- make_vertex_patches(SparsityPattern & block_list,
+ make_vertex_patches(SparsityPattern &block_list,
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
const bool interior_only,
template <int dim, int spacedim>
std::vector<unsigned int>
- make_vertex_patches(SparsityPattern & block_list,
+ make_vertex_patches(SparsityPattern &block_list,
const DoFHandler<dim, spacedim> &dof_handler,
const unsigned int level,
- const BlockMask & exclude_boundary_dofs,
+ const BlockMask &exclude_boundary_dofs,
const bool boundary_patches,
const bool level_boundary_patches,
const bool single_cell_patches,
template void
extract_locally_relevant_dofs<deal_II_dimension, deal_II_space_dimension>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension>
- & dof_handler,
+ &dof_handler,
IndexSet &dof_set);
template IndexSet
extract_locally_relevant_level_dofs<deal_II_dimension,
deal_II_space_dimension>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension>
- & dof_handler,
+ &dof_handler,
const unsigned int level);
template void
extract_locally_relevant_level_dofs<deal_II_dimension,
deal_II_space_dimension>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension>
- & dof_handler,
+ &dof_handler,
const unsigned int level,
- IndexSet & dof_set);
+ IndexSet &dof_set);
template IndexSet
extract_locally_active_dofs<deal_II_dimension, deal_II_space_dimension>(
template void
extract_locally_active_dofs<deal_II_dimension, deal_II_space_dimension>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension>
- & dof_handler,
+ &dof_handler,
IndexSet &dof_set);
template IndexSet
extract_locally_active_level_dofs<deal_II_dimension,
deal_II_space_dimension>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension>
- & dof_handler,
+ &dof_handler,
const unsigned int level);
template void
extract_locally_active_level_dofs<deal_II_dimension,
deal_II_space_dimension>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension>
- & dof_handler,
- IndexSet & dof_set,
+ &dof_handler,
+ IndexSet &dof_set,
const unsigned int level);
template std::vector<IndexSet>
locally_owned_dofs_per_component<deal_II_dimension,
deal_II_space_dimension>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension>
- & dof_handler,
+ &dof_handler,
const ComponentMask &components);
template std::vector<types::global_dof_index>
template void DoFTools::extract_subdomain_dofs<deal_II_dimension>(
const DoFHandler<deal_II_dimension> &dof_handler,
const types::subdomain_id subdomain_id,
- std::vector<bool> & selected_dofs);
+ std::vector<bool> &selected_dofs);
template void DoFTools::extract_constant_modes<deal_II_dimension>(
const DoFHandler<deal_II_dimension> &dof_handler,
- const ComponentMask & selected_components,
- std::vector<std::vector<bool>> & constant_modes);
+ const ComponentMask &selected_components,
+ std::vector<std::vector<bool>> &constant_modes);
template void DoFTools::get_active_fe_indices<deal_II_dimension>(
const DoFHandler<deal_II_dimension> &dof_handler,
- std::vector<unsigned int> & active_fe_indices);
+ std::vector<unsigned int> &active_fe_indices);
template void DoFTools::get_subdomain_association<deal_II_dimension>(
const DoFHandler<deal_II_dimension> &dof_handler,
- std::vector<types::subdomain_id> & subdomain_association);
+ std::vector<types::subdomain_id> &subdomain_association);
template std::vector<IndexSet>
DoFTools::locally_owned_dofs_per_subdomain<deal_II_dimension>(
const std::set<types::boundary_id> &);
template void DoFTools::get_subdomain_association<1, 3>(
- const DoFHandler<1, 3> & dof_handler,
+ const DoFHandler<1, 3> &dof_handler,
std::vector<types::subdomain_id> &subdomain_association);
template std::vector<IndexSet>
template void
distribute_cell_to_dof_vector<deal_II_dimension, deal_II_space_dimension>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension>
- & dof_handler,
+ &dof_handler,
const Vector<float> &cell_data,
- Vector<double> & dof_data,
+ Vector<double> &dof_data,
const unsigned int component);
template void
distribute_cell_to_dof_vector<deal_II_dimension, deal_II_space_dimension>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension>
- & dof_handler,
+ &dof_handler,
const Vector<double> &cell_data,
- Vector<double> & dof_data,
+ Vector<double> &dof_data,
const unsigned int component);
\}
#endif
{
inline bool
check_primary_dof_list(
- const FullMatrix<double> & face_interpolation_matrix,
+ const FullMatrix<double> &face_interpolation_matrix,
const std::vector<types::global_dof_index> &primary_dof_list)
{
const unsigned int N = primary_dof_list.size();
select_primary_dofs_for_face_restriction(
const FiniteElement<dim, spacedim> &fe1,
const FiniteElement<dim, spacedim> &fe2,
- const FullMatrix<double> & face_interpolation_matrix,
- std::vector<bool> & primary_dof_mask)
+ const FullMatrix<double> &face_interpolation_matrix,
+ std::vector<bool> &primary_dof_mask)
{
// TODO: the implementation makes the assumption that all faces have the
// same number of dofs
ensure_existence_of_primary_dof_mask(
const FiniteElement<dim, spacedim> &fe1,
const FiniteElement<dim, spacedim> &fe2,
- const FullMatrix<double> & face_interpolation_matrix,
+ const FullMatrix<double> &face_interpolation_matrix,
std::unique_ptr<std::vector<bool>> &primary_dof_mask)
{
// TODO: the implementation makes the assumption that all faces have the
template <int dim, int spacedim>
void
ensure_existence_of_face_matrix(
- const FiniteElement<dim, spacedim> & fe1,
- const FiniteElement<dim, spacedim> & fe2,
+ const FiniteElement<dim, spacedim> &fe1,
+ const FiniteElement<dim, spacedim> &fe2,
std::unique_ptr<FullMatrix<double>> &matrix)
{
// TODO: the implementation makes the assumption that all faces have the
template <int dim, int spacedim>
void
ensure_existence_of_subface_matrix(
- const FiniteElement<dim, spacedim> & fe1,
- const FiniteElement<dim, spacedim> & fe2,
+ const FiniteElement<dim, spacedim> &fe1,
+ const FiniteElement<dim, spacedim> &fe2,
const unsigned int subface,
std::unique_ptr<FullMatrix<double>> &matrix)
{
void
ensure_existence_of_split_face_matrix(
const FullMatrix<double> &face_interpolation_matrix,
- const std::vector<bool> & primary_dof_mask,
+ const std::vector<bool> &primary_dof_mask,
std::unique_ptr<std::pair<FullMatrix<double>, FullMatrix<double>>>
&split_matrix)
{
filter_constraints(
const std::vector<types::global_dof_index> &primary_dofs,
const std::vector<types::global_dof_index> &dependent_dofs,
- const FullMatrix<number1> & face_constraints,
- AffineConstraints<number2> & constraints)
+ const FullMatrix<number1> &face_constraints,
+ AffineConstraints<number2> &constraints)
{
Assert(face_constraints.n() == primary_dofs.size(),
ExcDimensionMismatch(primary_dofs.size(), face_constraints.n()));
void
make_oldstyle_hanging_node_constraints(
const DoFHandler<dim_, spacedim> &dof_handler,
- AffineConstraints<number> & constraints,
+ AffineConstraints<number> &constraints,
std::integral_constant<int, 2>)
{
const unsigned int dim = 2;
void
make_oldstyle_hanging_node_constraints(
const DoFHandler<dim_, spacedim> &dof_handler,
- AffineConstraints<number> & constraints,
+ AffineConstraints<number> &constraints,
std::integral_constant<int, 3>)
{
const unsigned int dim = 3;
void
make_hp_hanging_node_constraints(
const DoFHandler<dim, spacedim> &dof_handler,
- AffineConstraints<number> & constraints)
+ AffineConstraints<number> &constraints)
{
// note: this function is going to be hard to understand if you haven't
// read the hp-paper. however, we try to follow the notation laid out
template <int dim, int spacedim, typename number>
void
make_hanging_node_constraints(const DoFHandler<dim, spacedim> &dof_handler,
- AffineConstraints<number> & constraints)
+ AffineConstraints<number> &constraints)
{
Assert(dof_handler.has_active_dofs(),
ExcMessage(
template <typename FaceIterator, typename number>
void
set_periodicity_constraints(
- const FaceIterator & face_1,
+ const FaceIterator &face_1,
const std_cxx20::type_identity_t<FaceIterator> &face_2,
- const FullMatrix<double> & transformation,
- AffineConstraints<number> & affine_constraints,
- const ComponentMask & component_mask,
+ const FullMatrix<double> &transformation,
+ AffineConstraints<number> &affine_constraints,
+ const ComponentMask &component_mask,
const bool face_orientation,
const bool face_flip,
const bool face_rotation,
FullMatrix<double>
compute_transformation(
const FiniteElement<dim, spacedim> &fe,
- const FullMatrix<double> & matrix,
- const std::vector<unsigned int> & first_vector_components)
+ const FullMatrix<double> &matrix,
+ const std::vector<unsigned int> &first_vector_components)
{
// TODO: the implementation makes the assumption that all faces have the
// same number of dofs
template <typename FaceIterator, typename number>
void
make_periodicity_constraints(
- const FaceIterator & face_1,
+ const FaceIterator &face_1,
const std_cxx20::type_identity_t<FaceIterator> &face_2,
- AffineConstraints<number> & affine_constraints,
- const ComponentMask & component_mask,
+ AffineConstraints<number> &affine_constraints,
+ const ComponentMask &component_mask,
const bool face_orientation,
const bool face_flip,
const bool face_rotation,
- const FullMatrix<double> & matrix,
- const std::vector<unsigned int> & first_vector_components,
+ const FullMatrix<double> &matrix,
+ const std::vector<unsigned int> &first_vector_components,
const number periodicity_factor)
{
static const int dim = FaceIterator::AccessorType::dimension;
make_periodicity_constraints(
const std::vector<GridTools::PeriodicFacePair<
typename DoFHandler<dim, spacedim>::cell_iterator>> &periodic_faces,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask,
+ AffineConstraints<number> &constraints,
+ const ComponentMask &component_mask,
const std::vector<unsigned int> &first_vector_components,
const number periodicity_factor)
{
template <int dim, int spacedim, typename number>
void
- make_periodicity_constraints(const DoFHandler<dim, spacedim> & dof_handler,
+ make_periodicity_constraints(const DoFHandler<dim, spacedim> &dof_handler,
const types::boundary_id b_id1,
const types::boundary_id b_id2,
const unsigned int direction,
make_periodicity_constraints(const DoFHandler<dim, spacedim> &dof_handler,
const types::boundary_id b_id,
const unsigned int direction,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask,
+ AffineConstraints<number> &constraints,
+ const ComponentMask &component_mask,
const number periodicity_factor)
{
AssertIndexRange(direction, spacedim);
compute_intergrid_weights_3(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const Assembler::Scratch &,
- Assembler::CopyData<dim, spacedim> & copy_data,
+ Assembler::CopyData<dim, spacedim> ©_data,
const unsigned int coarse_component,
- const FiniteElement<dim, spacedim> & coarse_fe,
+ const FiniteElement<dim, spacedim> &coarse_fe,
const InterGridMap<DoFHandler<dim, spacedim>> &coarse_to_fine_grid_map,
- const std::vector<dealii::Vector<double>> & parameter_dofs)
+ const std::vector<dealii::Vector<double>> ¶meter_dofs)
{
// for each cell on the parameter grid: find out which degrees of
// freedom on the fine grid correspond in which way to the degrees of
template <int dim, int spacedim>
void
copy_intergrid_weights_3(
- const Assembler::CopyData<dim, spacedim> & copy_data,
+ const Assembler::CopyData<dim, spacedim> ©_data,
const unsigned int coarse_component,
- const FiniteElement<dim, spacedim> & coarse_fe,
+ const FiniteElement<dim, spacedim> &coarse_fe,
const std::vector<types::global_dof_index> &weight_mapping,
const bool is_called_in_parallel,
std::vector<std::map<types::global_dof_index, float>> &weights)
template <int dim, int spacedim>
void
compute_intergrid_weights_2(
- const DoFHandler<dim, spacedim> & coarse_grid,
+ const DoFHandler<dim, spacedim> &coarse_grid,
const unsigned int coarse_component,
const InterGridMap<DoFHandler<dim, spacedim>> &coarse_to_fine_grid_map,
- const std::vector<dealii::Vector<double>> & parameter_dofs,
- const std::vector<types::global_dof_index> & weight_mapping,
+ const std::vector<dealii::Vector<double>> ¶meter_dofs,
+ const std::vector<types::global_dof_index> &weight_mapping,
std::vector<std::map<types::global_dof_index, float>> &weights)
{
Assembler::Scratch scratch;
&coarse_to_fine_grid_map,
¶meter_dofs](
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & cell,
- const Assembler::Scratch & scratch_data,
+ &cell,
+ const Assembler::Scratch &scratch_data,
Assembler::CopyData<dim, spacedim> ©_data) {
compute_intergrid_weights_3<dim, spacedim>(cell,
scratch_data,
template <int dim, int spacedim>
unsigned int
compute_intergrid_weights_1(
- const DoFHandler<dim, spacedim> & coarse_grid,
+ const DoFHandler<dim, spacedim> &coarse_grid,
const unsigned int coarse_component,
- const DoFHandler<dim, spacedim> & fine_grid,
+ const DoFHandler<dim, spacedim> &fine_grid,
const unsigned int fine_component,
const InterGridMap<DoFHandler<dim, spacedim>> &coarse_to_fine_grid_map,
std::vector<std::map<types::global_dof_index, float>> &weights,
- std::vector<types::global_dof_index> & weight_mapping)
+ std::vector<types::global_dof_index> &weight_mapping)
{
// aliases to the finite elements used by the dof handlers:
const FiniteElement<dim, spacedim> &coarse_fe = coarse_grid.get_fe(),
template <int dim, int spacedim>
void
compute_intergrid_constraints(
- const DoFHandler<dim, spacedim> & coarse_grid,
+ const DoFHandler<dim, spacedim> &coarse_grid,
const unsigned int coarse_component,
- const DoFHandler<dim, spacedim> & fine_grid,
+ const DoFHandler<dim, spacedim> &fine_grid,
const unsigned int fine_component,
const InterGridMap<DoFHandler<dim, spacedim>> &coarse_to_fine_grid_map,
- AffineConstraints<double> & constraints)
+ AffineConstraints<double> &constraints)
{
Assert(coarse_grid.get_fe_collection().size() == 1 &&
fine_grid.get_fe_collection().size() == 1,
template <int dim, int spacedim>
void
compute_intergrid_transfer_representation(
- const DoFHandler<dim, spacedim> & coarse_grid,
+ const DoFHandler<dim, spacedim> &coarse_grid,
const unsigned int coarse_component,
- const DoFHandler<dim, spacedim> & fine_grid,
+ const DoFHandler<dim, spacedim> &fine_grid,
const unsigned int fine_component,
const InterGridMap<DoFHandler<dim, spacedim>> &coarse_to_fine_grid_map,
std::vector<std::map<types::global_dof_index, float>>
make_zero_boundary_constraints(
const DoFHandler<dim, spacedim> &dof,
const types::boundary_id boundary_id,
- AffineConstraints<number> & zero_boundary_constraints,
- const ComponentMask & component_mask)
+ AffineConstraints<number> &zero_boundary_constraints,
+ const ComponentMask &component_mask)
{
Assert(component_mask.represents_n_components(dof.get_fe(0).n_components()),
ExcMessage("The number of components in the mask has to be either "
void
make_zero_boundary_constraints(
const DoFHandler<dim, spacedim> &dof,
- AffineConstraints<number> & zero_boundary_constraints,
- const ComponentMask & component_mask)
+ AffineConstraints<number> &zero_boundary_constraints,
+ const ComponentMask &component_mask)
{
make_zero_boundary_constraints(dof,
numbers::invalid_boundary_id,
template <int dim, int spacedim, typename number>
void
make_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
const types::subdomain_id subdomain_id)
template <int dim, int spacedim, typename number>
void
make_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
- const Table<2, Coupling> & couplings,
- SparsityPatternBase & sparsity,
+ const Table<2, Coupling> &couplings,
+ SparsityPatternBase &sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
const types::subdomain_id subdomain_id)
void
make_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_row,
const DoFHandler<dim, spacedim> &dof_col,
- SparsityPatternBase & sparsity)
+ SparsityPatternBase &sparsity)
{
const types::global_dof_index n_dofs_row = dof_row.n_dofs();
const types::global_dof_index n_dofs_col = dof_col.n_dofs();
template <int dim, int spacedim>
void
make_boundary_sparsity_pattern(
- const DoFHandler<dim, spacedim> & dof,
+ const DoFHandler<dim, spacedim> &dof,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparsityPatternBase & sparsity)
+ SparsityPatternBase &sparsity)
{
if (dim == 1)
{
make_boundary_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_ids,
+ &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparsityPatternBase & sparsity)
+ SparsityPatternBase &sparsity)
{
if (dim == 1)
{
template <int dim, int spacedim, typename number>
void
make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
const types::subdomain_id subdomain_id)
template <int dim, int spacedim>
void
make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
- SparsityPatternBase & sparsity)
+ SparsityPatternBase &sparsity)
{
AffineConstraints<double> dummy;
make_flux_sparsity_pattern(dof, sparsity, dummy);
Table<2, Coupling>
dof_couplings_from_component_couplings(
const FiniteElement<dim, spacedim> &fe,
- const Table<2, Coupling> & component_couplings)
+ const Table<2, Coupling> &component_couplings)
{
Assert(component_couplings.n_rows() == fe.n_components(),
ExcDimensionMismatch(component_couplings.n_rows(),
std::vector<Table<2, Coupling>>
dof_couplings_from_component_couplings(
const hp::FECollection<dim, spacedim> &fe,
- const Table<2, Coupling> & component_couplings)
+ const Table<2, Coupling> &component_couplings)
{
std::vector<Table<2, Coupling>> return_value(fe.size());
for (unsigned int i = 0; i < fe.size(); ++i)
void
make_flux_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
- const Table<2, Coupling> & int_mask,
- const Table<2, Coupling> & flux_mask,
+ const Table<2, Coupling> &int_mask,
+ const Table<2, Coupling> &flux_mask,
const types::subdomain_id subdomain_id,
const std::function<
bool(const typename DoFHandler<dim, spacedim>::active_cell_iterator &,
template <int dim, int spacedim>
void
make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
- SparsityPatternBase & sparsity,
- const Table<2, Coupling> & int_mask,
- const Table<2, Coupling> & flux_mask,
+ SparsityPatternBase &sparsity,
+ const Table<2, Coupling> &int_mask,
+ const Table<2, Coupling> &flux_mask,
const types::subdomain_id subdomain_id)
{
AffineConstraints<double> dummy;
void
make_flux_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
- const Table<2, Coupling> & int_mask,
- const Table<2, Coupling> & flux_mask,
+ const Table<2, Coupling> &int_mask,
+ const Table<2, Coupling> &flux_mask,
const types::subdomain_id subdomain_id,
const std::function<
bool(const typename DoFHandler<dim, spacedim>::active_cell_iterator &,
template void DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,
deal_II_dimension,
scalar>(
- const DoFHandler<deal_II_dimension> & dof,
+ const DoFHandler<deal_II_dimension> &dof,
const std::map<types::boundary_id,
const Function<deal_II_dimension, scalar> *> &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparsityPatternBase & sparsity);
+ SparsityPatternBase &sparsity);
#if deal_II_dimension < 3
const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
const std::map<types::boundary_id,
const Function<deal_II_dimension + 1, scalar> *>
- & boundary_ids,
+ &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparsityPatternBase & sparsity);
+ SparsityPatternBase &sparsity);
#endif
const DoFHandler<deal_II_dimension, deal_II_dimension + 2> &dof,
const std::map<types::boundary_id,
const Function<deal_II_dimension + 2, scalar> *>
- & boundary_ids,
+ &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparsityPatternBase & sparsity);
+ SparsityPatternBase &sparsity);
#endif
}
template void
DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
const DoFHandler<deal_II_dimension, deal_II_dimension> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<S> &,
const bool,
const types::subdomain_id);
template void
DoFTools::make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
const DoFHandler<deal_II_dimension> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<S> &,
const bool,
const Table<2, Coupling> &,
template void
DoFTools::make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
const DoFHandler<deal_II_dimension> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<S> &,
const bool,
const types::subdomain_id);
template void
DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1>(
const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<S> &,
const bool,
const types::subdomain_id);
template void DoFTools::make_flux_sparsity_pattern<deal_II_dimension,
deal_II_dimension + 1>(
const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<S> &,
const bool,
const Table<2, Coupling> &,
template void DoFTools::make_flux_sparsity_pattern<deal_II_dimension,
deal_II_dimension + 1>(
const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<S> &,
const bool,
const types::subdomain_id);
template void DoFTools::make_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<S> &,
const bool,
const types::subdomain_id);
template void DoFTools::make_flux_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<S> &,
const bool,
const Table<2, Coupling> &,
template void DoFTools::make_flux_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const AffineConstraints<S> &,
const bool,
const types::subdomain_id);
DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
const DoFHandler<deal_II_dimension, deal_II_dimension> &dof_row,
const DoFHandler<deal_II_dimension, deal_II_dimension> &dof_col,
- SparsityPatternBase & sparsity);
+ SparsityPatternBase &sparsity);
template void DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,
deal_II_dimension>(
template void
DoFTools::make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
const DoFHandler<deal_II_dimension> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const Table<2, Coupling> &,
const Table<2, Coupling> &,
const types::subdomain_id);
template void DoFTools::make_flux_sparsity_pattern<deal_II_dimension,
deal_II_dimension + 1>(
const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
- SparsityPatternBase & sparsity);
+ SparsityPatternBase &sparsity);
template void DoFTools::make_flux_sparsity_pattern<deal_II_dimension,
deal_II_dimension + 1>(
const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const Table<2, Coupling> &,
const Table<2, Coupling> &,
const types::subdomain_id);
DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1>(
const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof_row,
const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof_col,
- SparsityPatternBase & sparsity);
+ SparsityPatternBase &sparsity);
template void
DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,
template void DoFTools::make_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof_row,
const DoFHandler<1, 3> &dof_col,
- SparsityPatternBase & sparsity);
+ SparsityPatternBase &sparsity);
template void DoFTools::make_boundary_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof,
template void DoFTools::make_flux_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const Table<2, Coupling> &,
const Table<2, Coupling> &,
const types::subdomain_id);
template Table<2, DoFTools::Coupling>
DoFTools::dof_couplings_from_component_couplings(
const FiniteElement<deal_II_dimension> &fe,
- const Table<2, DoFTools::Coupling> & component_couplings);
+ const Table<2, DoFTools::Coupling> &component_couplings);
template std::vector<Table<2, DoFTools::Coupling>>
DoFTools::dof_couplings_from_component_couplings(
const hp::FECollection<deal_II_dimension> &fe,
- const Table<2, DoFTools::Coupling> & component_couplings);
+ const Table<2, DoFTools::Coupling> &component_couplings);
}
template <int dim, int spacedim>
FiniteElement<dim, spacedim>::FiniteElement(
- const FiniteElementData<dim> & fe_data,
- const std::vector<bool> & r_i_a_f,
+ const FiniteElementData<dim> &fe_data,
+ const std::vector<bool> &r_i_a_f,
const std::vector<ComponentMask> &nonzero_c)
: FiniteElementData<dim>(fe_data)
, adjust_line_dof_index_for_line_orientation_table(this->n_dofs_per_line())
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
FiniteElement<dim, spacedim>::get_face_data(
const UpdateFlags flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const hp::QCollection<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
FiniteElement<dim, spacedim>::get_face_data(
const UpdateFlags flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const
FiniteElement<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
FiniteElement<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
FiniteElement<dim, spacedim>::get_subface_data(
const UpdateFlags flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const
void
FE_ABF<dim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
Assert(support_point_values.size() == this->generalized_support_points.size(),
ExcDimensionMismatch(support_point_values.size(),
void
FE_BDM<dim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
Assert(support_point_values.size() == this->generalized_support_points.size(),
ExcDimensionMismatch(support_point_values.size(),
template <int dim>
void
initialize_test_values(std::vector<std::vector<double>> &test_values,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const unsigned int deg)
{
PolynomialsP<dim> poly(deg);
void
FE_BernardiRaugel<dim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
Assert(support_point_values.size() == this->generalized_support_points.size(),
ExcDimensionMismatch(support_point_values.size(),
void
FE_Bernstein<dim, spacedim>::get_face_interpolation_matrix(
const FiniteElement<dim, spacedim> &source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
get_subface_interpolation_matrix(source_fe,
FE_Bernstein<dim, spacedim>::get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
const unsigned int subface,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
Assert(interpolation_matrix.m() == x_source_fe.n_dofs_per_face(face_no),
const unsigned int n_components,
const unsigned int degree,
const Conformity conformity,
- const BlockIndices & block_indices)
+ const BlockIndices &block_indices)
: FiniteElementData(dofs_per_object,
dim == 0 ?
ReferenceCells::Vertex :
const unsigned int n_components,
const unsigned int degree,
const Conformity conformity,
- const BlockIndices & block_indices)
+ const BlockIndices &block_indices)
: FiniteElementData(internal::expand(dim, dofs_per_object, cell_type),
cell_type,
n_components,
const unsigned int n_components,
const unsigned int degree,
const Conformity conformity,
- const BlockIndices & block_indices)
+ const BlockIndices &block_indices)
: reference_cell_kind(reference_cell)
, number_of_unique_2d_subobjects(
internal::number_unique_entries(data.dofs_per_object_inclusive[2]))
void
FE_DGP<dim, spacedim>::get_face_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int) const
{
// this is only implemented, if the source FE is also a DGP element. in that
// dofs 1 4 10 20 35 56 84 120
const unsigned int start_index3d[6] = {0, 1, 5, 15 /*,35*/};
const double points3d[35][3] = {{0, 0, 0},
- {0, 0, 0},
- {1, 0, 0},
- {0, 1, 0},
- {0, 0, 1},
- {0, 0, 0},
- {1, 0, 0},
- {0, 1, 0},
- {0, 0, 1},
- {0.5, 0, 0},
- {0, 0.5, 0},
- {0, 0, 0.5},
- {1, 1, 0},
- {1, 0, 1},
- {0, 1, 1}};
+ {0, 0, 0},
+ {1, 0, 0},
+ {0, 1, 0},
+ {0, 0, 1},
+ {0, 0, 0},
+ {1, 0, 0},
+ {0, 1, 0},
+ {0, 0, 1},
+ {0.5, 0, 0},
+ {0, 0.5, 0},
+ {0, 0, 0.5},
+ {1, 1, 0},
+ {1, 0, 1},
+ {0, 1, 1}};
template <int dim>
void
FE_DGPMonomial<dim>::get_interpolation_matrix(
const FiniteElement<dim> &source_fe,
- FullMatrix<double> & interpolation_matrix) const
+ FullMatrix<double> &interpolation_matrix) const
{
const FE_DGPMonomial<dim> *source_dgp_monomial =
dynamic_cast<const FE_DGPMonomial<dim> *>(&source_fe);
void
FE_DGPMonomial<dim>::get_face_interpolation_matrix(
const FiniteElement<dim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int) const
{
// this is only implemented, if the source
template <int dim, int spacedim>
double
FE_DGPNonparametric<dim, spacedim>::shape_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
(void)i;
(void)p;
double
FE_DGPNonparametric<dim, spacedim>::shape_value_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
(void)i;
template <int dim, int spacedim>
Tensor<1, dim>
FE_DGPNonparametric<dim, spacedim>::shape_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
(void)i;
(void)p;
Tensor<1, dim>
FE_DGPNonparametric<dim, spacedim>::shape_grad_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
(void)i;
template <int dim, int spacedim>
Tensor<2, dim>
FE_DGPNonparametric<dim, spacedim>::shape_grad_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
(void)i;
(void)p;
Tensor<2, dim>
FE_DGPNonparametric<dim, spacedim>::shape_grad_grad_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
(void)i;
const Mapping<dim, spacedim> &,
const typename Mapping<dim, spacedim>::InternalDataBase &,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const Mapping<dim, spacedim> &,
const typename Mapping<dim, spacedim>::InternalDataBase &,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const Mapping<dim, spacedim> &,
const typename Mapping<dim, spacedim>::InternalDataBase &,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
void
FE_DGPNonparametric<dim, spacedim>::get_face_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int) const
{
// this is only implemented, if the source
void
FE_DGQ<dim, spacedim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
AssertDimension(support_point_values.size(),
this->get_unit_support_points().size());
void
FE_DGQ<dim, spacedim>::get_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix) const
+ FullMatrix<double> &interpolation_matrix) const
{
// this is only implemented, if the
// source FE is also a
void
FE_DGQ<dim, spacedim>::get_face_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int) const
{
// this is only implemented, if the source
FE_DGQArbitraryNodes<dim, spacedim>::
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
AssertDimension(support_point_values.size(),
this->get_unit_support_points().size());
template <int dim, int spacedim>
std::vector<const FiniteElement<dim, spacedim> *>
build_fes(
- const FiniteElement<dim, spacedim> * fe_base,
+ const FiniteElement<dim, spacedim> *fe_base,
const std::vector<const FiniteElement<dim, spacedim> *> &fe_enriched)
{
std::vector<const FiniteElement<dim, spacedim> *> fes;
bool
consistency_check(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities,
+ const std::vector<unsigned int> &multiplicities,
const std::vector<std::vector<std::function<const Function<spacedim> *(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- &)>>> & functions)
+ &)>>> &functions)
{
AssertThrow(fes.size() > 0, ExcMessage("FEs size should be >=1"));
AssertThrow(fes.size() == multiplicities.size(),
FE_Enriched<dim, spacedim>::FE_Enriched(
const FiniteElement<dim, spacedim> &fe_base,
const FiniteElement<dim, spacedim> &fe_enriched,
- const Function<spacedim> * enrichment_function)
+ const Function<spacedim> *enrichment_function)
: FE_Enriched<dim, spacedim>(
&fe_base,
std::vector<const FiniteElement<dim, spacedim> *>(1, &fe_enriched),
template <int dim, int spacedim>
FE_Enriched<dim, spacedim>::FE_Enriched(
- const FiniteElement<dim, spacedim> * fe_base,
+ const FiniteElement<dim, spacedim> *fe_base,
const std::vector<const FiniteElement<dim, spacedim> *> &fe_enriched,
const std::vector<std::vector<std::function<const Function<spacedim> *(
const typename Triangulation<dim, spacedim>::cell_iterator &)>>> &functions)
template <int dim, int spacedim>
FE_Enriched<dim, spacedim>::FE_Enriched(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities,
+ const std::vector<unsigned int> &multiplicities,
const std::vector<std::vector<std::function<const Function<spacedim> *(
const typename Triangulation<dim, spacedim>::cell_iterator &)>>> &functions)
: FiniteElement<dim, spacedim>(
template <int dim, int spacedim>
double
FE_Enriched<dim, spacedim>::shape_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
Assert(
!is_enriched,
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
FE_Enriched<dim, spacedim>::get_face_data(
const UpdateFlags update_flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const hp::QCollection<dim - 1> &quadrature,
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data) const
FE_Enriched<dim, spacedim>::get_subface_data(
const UpdateFlags update_flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
&output_data) const
FE_Enriched<dim, spacedim>::get_data(
const UpdateFlags flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data) const
{
void
FE_Enriched<dim, spacedim>::initialize(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities)
+ const std::vector<unsigned int> &multiplicities)
{
Assert(fes.size() == multiplicities.size(),
ExcDimensionMismatch(fes.size(), multiplicities.size()));
FE_Enriched<dim, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data) const
FE_Enriched<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data) const
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data) const
void
FE_Enriched<dim, spacedim>::multiply_by_enrichment(
const Quadrature<dim_1> &quadrature,
- const InternalData & fe_data,
+ const InternalData &fe_data,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&output_data) const
void
FE_Enriched<dim, spacedim>::get_face_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no) const
{
if (const FE_Enriched<dim, spacedim> *fe_enr_other =
FE_Enriched<dim, spacedim>::get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source,
const unsigned int subface,
- FullMatrix<double> & matrix,
+ FullMatrix<double> &matrix,
const unsigned int face_no) const
{
if (const FE_Enriched<dim, spacedim> *fe_enr_other =
template <int dim, int spacedim>
bool
find_connection_between_subdomains(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
const predicate_function<dim, spacedim> &predicate_1,
const predicate_function<dim, spacedim> &predicate_2)
{
template <int dim, int spacedim>
unsigned int
color_predicates(
- const DoFHandler<dim, spacedim> & mesh,
+ const DoFHandler<dim, spacedim> &mesh,
const std::vector<predicate_function<dim, spacedim>> &predicates,
- std::vector<unsigned int> & predicate_colors)
+ std::vector<unsigned int> &predicate_colors)
{
const unsigned int num_indices = predicates.size();
template <int dim, int spacedim>
void
set_cellwise_color_set_and_fe_index(
- DoFHandler<dim, spacedim> & dof_handler,
+ DoFHandler<dim, spacedim> &dof_handler,
const std::vector<predicate_function<dim, spacedim>> &predicates,
- const std::vector<unsigned int> & predicate_colors,
+ const std::vector<unsigned int> &predicate_colors,
std::map<unsigned int, std::map<unsigned int, unsigned int>>
- & cellwise_color_predicate_map,
+ &cellwise_color_predicate_map,
std::vector<std::set<unsigned int>> &fe_sets)
{
// clear output variables first
const std::vector<std::set<unsigned int>> &fe_sets,
const std::vector<std::function<const Function<spacedim> *(
const typename Triangulation<dim, spacedim>::cell_iterator &)>>
- & color_enrichments,
+ &color_enrichments,
const FiniteElement<dim, spacedim> &fe_base,
const FiniteElement<dim, spacedim> &fe_enriched,
- const FE_Nothing<dim, spacedim> & fe_nothing,
- hp::FECollection<dim, spacedim> & fe_collection)
+ const FE_Nothing<dim, spacedim> &fe_nothing,
+ hp::FECollection<dim, spacedim> &fe_collection)
{
// define dummy function which is associated with FE_Nothing
const std::function<const Function<spacedim> *(
template <int dim, int spacedim>
Helper<dim, spacedim>::Helper(
- const FiniteElement<dim, spacedim> & fe_base,
- const FiniteElement<dim, spacedim> & fe_enriched,
- const std::vector<predicate_function<dim, spacedim>> & predicates,
+ const FiniteElement<dim, spacedim> &fe_base,
+ const FiniteElement<dim, spacedim> &fe_enriched,
+ const std::vector<predicate_function<dim, spacedim>> &predicates,
const std::vector<std::shared_ptr<Function<spacedim>>> &enrichments)
: fe_base(fe_base)
, fe_enriched(fe_enriched)
DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof_handler,
const std::vector<
predicate_function<deal_II_dimension, deal_II_space_dimension>>
- & predicates,
+ &predicates,
const std::vector<unsigned int> &predicate_colors,
std::map<unsigned int, std::map<unsigned int, unsigned int>>
- & cellwise_color_predicate_map,
+ &cellwise_color_predicate_map,
std::vector<std::set<unsigned int>> &fe_sets);
const std::vector<std::shared_ptr<Function<deal_II_space_dimension>>>
&enrichments,
const std::map<unsigned int, std::map<unsigned int, unsigned int>>
- & cellwise_color_predicate_map,
+ &cellwise_color_predicate_map,
std::vector<std::function<const Function<deal_II_space_dimension> *(
const typename Triangulation<deal_II_dimension,
deal_II_space_dimension>::cell_iterator
void
FE_FaceQ<dim, spacedim>::get_face_interpolation_matrix(
const FiniteElement<dim, spacedim> &source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
get_subface_interpolation_matrix(source_fe,
FE_FaceQ<dim, spacedim>::get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
const unsigned int subface,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
// this function is similar to the respective method in FE_Q
void
FE_FaceQ<dim, spacedim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
AssertDimension(support_point_values.size(),
this->get_unit_support_points().size());
void
FE_FaceQ<1, spacedim>::get_face_interpolation_matrix(
const FiniteElement<1, spacedim> &source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
get_subface_interpolation_matrix(source_fe,
void
FE_FaceP<dim, spacedim>::get_face_interpolation_matrix(
const FiniteElement<dim, spacedim> &source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
get_subface_interpolation_matrix(source_fe,
FE_FaceP<dim, spacedim>::get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
const unsigned int subface,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
// this function is similar to the respective method in FE_Q
DEAL_II_NAMESPACE_OPEN
-//#define DEBUG_NEDELEC
+// #define DEBUG_NEDELEC
namespace internal
{
void
FE_Nedelec<dim>::get_face_interpolation_matrix(
const FiniteElement<dim> &source,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
(void)face_no;
FE_Nedelec<dim>::get_subface_interpolation_matrix(
const FiniteElement<dim> &source,
const unsigned int subface,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
// this is only implemented, if the
void
FE_Nedelec<dim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
// TODO: the implementation makes the assumption that all faces have the
// same number of dofs
void
FE_NedelecSZ<dim, spacedim>::fill_edge_values(
const typename Triangulation<dim, dim>::cell_iterator &cell,
- const Quadrature<dim> & quadrature,
- const InternalData & fe_data) const
+ const Quadrature<dim> &quadrature,
+ const InternalData &fe_data) const
{
// This function handles the cell-dependent construction of the EDGE-based
// shape functions.
void
FE_NedelecSZ<dim, spacedim>::fill_face_values(
const typename Triangulation<dim, dim>::cell_iterator &cell,
- const Quadrature<dim> & quadrature,
- const InternalData & fe_data) const
+ const Quadrature<dim> &quadrature,
+ const InternalData &fe_data) const
{
// This function handles the cell-dependent construction of the FACE-based
// shape functions.
FE_NedelecSZ<dim, spacedim>::fill_fe_values(
const typename Triangulation<dim, dim>::cell_iterator &cell,
const CellSimilarity::Similarity /*cell_similarity*/,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, dim> & mapping,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, dim> &mapping,
const typename Mapping<dim, dim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, dim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, dim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, dim>
&data) const
FE_NedelecSZ<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, dim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, dim> & mapping,
- const typename Mapping<dim, dim>::InternalDataBase & mapping_internal,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, dim> &mapping,
+ const typename Mapping<dim, dim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, dim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, dim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, dim>
&data) const
const Mapping<2, 2> &,
const Mapping<2, 2>::InternalDataBase &,
const internal::FEValuesImplementation::MappingRelatedData<2, 2>
- & mapping_data,
+ &mapping_data,
const FiniteElement<2, 2>::InternalDataBase &fe_internal,
internal::FEValuesImplementation::FiniteElementRelatedData<2, 2> &output_data)
const
FE_P1NC::fill_fe_face_values(
const Triangulation<2, 2>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<1> & quadrature,
- const Mapping<2, 2> & mapping,
+ const hp::QCollection<1> &quadrature,
+ const Mapping<2, 2> &mapping,
const Mapping<2, 2>::InternalDataBase &,
const internal::FEValuesImplementation::MappingRelatedData<2, 2> &,
const InternalDataBase &fe_internal,
const Triangulation<2, 2>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<1> & quadrature,
- const Mapping<2, 2> & mapping,
+ const Quadrature<1> &quadrature,
+ const Mapping<2, 2> &mapping,
const Mapping<2, 2>::InternalDataBase &,
const internal::FEValuesImplementation::MappingRelatedData<2, 2> &,
const InternalDataBase &fe_internal,
void
get_dof_sign_change_h_div(
const typename dealii::Triangulation<2, spacedim>::cell_iterator &cell,
- const FiniteElement<2, spacedim> & fe,
+ const FiniteElement<2, spacedim> &fe,
const std::vector<MappingKind> &mapping_kind,
- std::vector<double> & face_sign)
+ std::vector<double> &face_sign)
{
const unsigned int dim = 2;
// const unsigned int spacedim = 2;
const typename dealii::Triangulation<2, spacedim>::cell_iterator &cell,
const FiniteElement<2, spacedim> & /*fe*/,
const std::vector<MappingKind> &mapping_kind,
- std::vector<double> & line_dof_sign)
+ std::vector<double> &line_dof_sign)
{
const unsigned int dim = 2;
// TODO: This fixes only lowest order
const typename dealii::Triangulation<3, spacedim>::cell_iterator &cell,
const FiniteElement<3, spacedim> & /*fe*/,
const std::vector<MappingKind> &mapping_kind,
- std::vector<double> & line_dof_sign)
+ std::vector<double> &line_dof_sign)
{
const unsigned int dim = 3;
// TODO: This is probably only going to work for those elements for
template <int dim, int spacedim>
FE_PolyTensor<dim, spacedim>::FE_PolyTensor(
const TensorPolynomialsBase<dim> &polynomials,
- const FiniteElementData<dim> & fe_data,
- const std::vector<bool> & restriction_is_additive_flags,
+ const FiniteElementData<dim> &fe_data,
+ const std::vector<bool> &restriction_is_additive_flags,
const std::vector<ComponentMask> &nonzero_components)
: FiniteElement<dim, spacedim>(fe_data,
restriction_is_additive_flags,
double
FE_PolyTensor<dim, spacedim>::shape_value_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
Tensor<1, dim>
FE_PolyTensor<dim, spacedim>::shape_grad_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
Tensor<2, dim>
FE_PolyTensor<dim, spacedim>::shape_grad_grad_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
FE_PolyTensor<dim, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
FE_PolyTensor<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
template <int dim, int spacedim>
FE_PyramidPoly<dim, spacedim>::FE_PyramidPoly(
const unsigned int degree,
- const internal::GenericDoFsPerObject & dpos,
+ const internal::GenericDoFsPerObject &dpos,
const typename FiniteElementData<dim>::Conformity conformity)
: dealii::FE_Poly<dim, spacedim>(
ScalarLagrangePolynomialPyramid<dim>(degree),
FE_PyramidPoly<dim, spacedim>::
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
AssertDimension(support_point_values.size(),
this->get_unit_support_points().size());
void
FE_Q<dim, spacedim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
AssertDimension(support_point_values.size(),
this->get_unit_support_points().size());
template <int dim, int spacedim>
FE_Q_Base<dim, spacedim>::FE_Q_Base(
const ScalarPolynomialsBase<dim> &poly_space,
- const FiniteElementData<dim> & fe_data,
- const std::vector<bool> & restriction_is_additive_flags)
+ const FiniteElementData<dim> &fe_data,
+ const std::vector<bool> &restriction_is_additive_flags)
: FE_Poly<dim, spacedim>(
poly_space,
fe_data,
void
FE_Q_Base<dim, spacedim>::get_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix) const
+ FullMatrix<double> &interpolation_matrix) const
{
// go through the list of elements we can interpolate from
if (const FE_Q_Base<dim, spacedim> *source_fe =
void
FE_Q_Base<dim, spacedim>::get_face_interpolation_matrix(
const FiniteElement<dim, spacedim> &source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
get_subface_interpolation_matrix(source_fe,
FE_Q_Base<dim, spacedim>::get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source_fe,
const unsigned int subface,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
Assert(interpolation_matrix.m() == source_fe.n_dofs_per_face(face_no),
template <int dim, int spacedim>
inline void
compute_embedding_matrices(
- const dealii::FE_Q_Bubbles<dim, spacedim> & fe,
+ const dealii::FE_Q_Bubbles<dim, spacedim> &fe,
std::vector<std::vector<FullMatrix<double>>> &matrices,
const bool isotropic_only)
{
FE_Q_Bubbles<dim, spacedim>::
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
Assert(support_point_values.size() == this->unit_support_points.size(),
ExcDimensionMismatch(support_point_values.size(),
void
FE_Q_Bubbles<dim, spacedim>::get_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix) const
+ FullMatrix<double> &interpolation_matrix) const
{
// We don't know how to do this properly, yet.
// However, for SolutionTransfer to work we need to provide an implementation
void
FE_Q_DG0<dim, spacedim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_dofs) const
+ std::vector<double> &nodal_dofs) const
{
Assert(support_point_values.size() == this->unit_support_points.size(),
ExcDimensionMismatch(support_point_values.size(),
void
FE_Q_DG0<dim, spacedim>::get_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix) const
+ FullMatrix<double> &interpolation_matrix) const
{
// this is only implemented, if the source FE is also a Q_DG0 element
using FEQDG0 = FE_Q_DG0<dim, spacedim>;
void
FE_Q_Hierarchical<dim>::get_interpolation_matrix(
const FiniteElement<dim> &source,
- FullMatrix<double> & matrix) const
+ FullMatrix<double> &matrix) const
{
// support interpolation between FE_Q_Hierarchical only.
if (const FE_Q_Hierarchical<dim> *source_fe =
void
FE_Q_Hierarchical<dim>::get_face_interpolation_matrix(
const FiniteElement<dim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
// this is only implemented, if the
FE_Q_Hierarchical<dim>::get_subface_interpolation_matrix(
const FiniteElement<dim> &x_source_fe,
const unsigned int subface,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
// this is only implemented, if the
FE_Q_iso_Q1<dim, spacedim>::
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
AssertDimension(support_point_values.size(),
this->get_unit_support_points().size());
void
FE_RannacherTurek<dim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
AssertDimension(support_point_values.size(),
this->generalized_support_points.size());
void
FE_RaviartThomas<dim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
Assert(support_point_values.size() == this->generalized_support_points.size(),
ExcDimensionMismatch(support_point_values.size(),
FE_RaviartThomasNodal<dim>::
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
Assert(support_point_values.size() == this->generalized_support_points.size(),
ExcDimensionMismatch(support_point_values.size(),
void
FE_RaviartThomasNodal<dim>::get_face_interpolation_matrix(
const FiniteElement<dim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
// this is only implemented, if the
FE_RaviartThomasNodal<dim>::get_subface_interpolation_matrix(
const FiniteElement<dim> &x_source_fe,
const unsigned int subface,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
// this is only implemented, if the source FE is also a RaviartThomasNodal
void
FE_RT_Bubbles<dim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
Assert(support_point_values.size() == this->generalized_support_points.size(),
ExcDimensionMismatch(support_point_values.size(),
template <int dim, int spacedim>
std::complex<double>
integrate(const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- const Tensor<1, dim> & k_vector,
+ const Quadrature<dim> &quadrature,
+ const Tensor<1, dim> &k_vector,
const unsigned int j,
const unsigned int component)
{
template <int spacedim>
void
ensure_existence(
- const std::vector<unsigned int> & n_coefficients_per_direction,
- const hp::FECollection<1, spacedim> & fe_collection,
- const hp::QCollection<1> & q_collection,
- const Table<1, Tensor<1, 1>> & k_vectors,
+ const std::vector<unsigned int> &n_coefficients_per_direction,
+ const hp::FECollection<1, spacedim> &fe_collection,
+ const hp::QCollection<1> &q_collection,
+ const Table<1, Tensor<1, 1>> &k_vectors,
const unsigned int fe,
const unsigned int component,
std::vector<FullMatrix<std::complex<double>>> &fourier_transform_matrices)
template <int spacedim>
void
ensure_existence(
- const std::vector<unsigned int> & n_coefficients_per_direction,
- const hp::FECollection<2, spacedim> & fe_collection,
- const hp::QCollection<2> & q_collection,
- const Table<2, Tensor<1, 2>> & k_vectors,
+ const std::vector<unsigned int> &n_coefficients_per_direction,
+ const hp::FECollection<2, spacedim> &fe_collection,
+ const hp::QCollection<2> &q_collection,
+ const Table<2, Tensor<1, 2>> &k_vectors,
const unsigned int fe,
const unsigned int component,
std::vector<FullMatrix<std::complex<double>>> &fourier_transform_matrices)
template <int spacedim>
void
ensure_existence(
- const std::vector<unsigned int> & n_coefficients_per_direction,
- const hp::FECollection<3, spacedim> & fe_collection,
- const hp::QCollection<3> & q_collection,
- const Table<3, Tensor<1, 3>> & k_vectors,
+ const std::vector<unsigned int> &n_coefficients_per_direction,
+ const hp::FECollection<3, spacedim> &fe_collection,
+ const hp::QCollection<3> &q_collection,
+ const Table<3, Tensor<1, 3>> &k_vectors,
const unsigned int fe,
const unsigned int component,
std::vector<FullMatrix<std::complex<double>>> &fourier_transform_matrices)
{
template <int dim, int spacedim>
Fourier<dim, spacedim>::Fourier(
- const std::vector<unsigned int> & n_coefficients_per_direction,
+ const std::vector<unsigned int> &n_coefficients_per_direction,
const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & q_collection,
+ const hp::QCollection<dim> &q_collection,
const unsigned int component_)
: n_coefficients_per_direction(n_coefficients_per_direction)
, fe_collection(&fe_collection)
template <typename Number>
void
Fourier<dim, spacedim>::calculate(
- const Vector<Number> & local_dof_values,
+ const Vector<Number> &local_dof_values,
const unsigned int cell_active_fe_index,
Table<dim, CoefficientType> &fourier_coefficients)
{
template <int dim, int spacedim>
double
integrate(const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- const TableIndices<dim> & indices,
+ const Quadrature<dim> &quadrature,
+ const TableIndices<dim> &indices,
const unsigned int dof,
const unsigned int component)
{
template <int spacedim>
void
ensure_existence(
- const std::vector<unsigned int> & n_coefficients_per_direction,
+ const std::vector<unsigned int> &n_coefficients_per_direction,
const hp::FECollection<1, spacedim> &fe_collection,
- const hp::QCollection<1> & q_collection,
+ const hp::QCollection<1> &q_collection,
const unsigned int fe,
const unsigned int component,
- std::vector<FullMatrix<double>> & legendre_transform_matrices)
+ std::vector<FullMatrix<double>> &legendre_transform_matrices)
{
AssertIndexRange(fe, fe_collection.size());
template <int spacedim>
void
ensure_existence(
- const std::vector<unsigned int> & n_coefficients_per_direction,
+ const std::vector<unsigned int> &n_coefficients_per_direction,
const hp::FECollection<2, spacedim> &fe_collection,
- const hp::QCollection<2> & q_collection,
+ const hp::QCollection<2> &q_collection,
const unsigned int fe,
const unsigned int component,
- std::vector<FullMatrix<double>> & legendre_transform_matrices)
+ std::vector<FullMatrix<double>> &legendre_transform_matrices)
{
AssertIndexRange(fe, fe_collection.size());
template <int spacedim>
void
ensure_existence(
- const std::vector<unsigned int> & n_coefficients_per_direction,
+ const std::vector<unsigned int> &n_coefficients_per_direction,
const hp::FECollection<3, spacedim> &fe_collection,
- const hp::QCollection<3> & q_collection,
+ const hp::QCollection<3> &q_collection,
const unsigned int fe,
const unsigned int component,
- std::vector<FullMatrix<double>> & legendre_transform_matrices)
+ std::vector<FullMatrix<double>> &legendre_transform_matrices)
{
AssertIndexRange(fe, fe_collection.size());
{
template <int dim, int spacedim>
Legendre<dim, spacedim>::Legendre(
- const std::vector<unsigned int> & n_coefficients_per_direction,
+ const std::vector<unsigned int> &n_coefficients_per_direction,
const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & q_collection,
+ const hp::QCollection<dim> &q_collection,
const unsigned int component_)
: n_coefficients_per_direction(n_coefficients_per_direction)
, fe_collection(&fe_collection)
Legendre<dim, spacedim>::calculate(
const dealii::Vector<Number> &local_dof_values,
const unsigned int cell_active_fe_index,
- Table<dim, CoefficientType> & legendre_coefficients)
+ Table<dim, CoefficientType> &legendre_coefficients)
{
for (unsigned int d = 0; d < dim; ++d)
AssertDimension(legendre_coefficients.size(d),
template <int dim, int spacedim>
FE_SimplexPoly<dim, spacedim>::FE_SimplexPoly(
const BarycentricPolynomials<dim> polynomials,
- const FiniteElementData<dim> & fe_data,
- const std::vector<Point<dim>> & unit_support_points,
+ const FiniteElementData<dim> &fe_data,
+ const std::vector<Point<dim>> &unit_support_points,
const std::vector<std::vector<Point<dim - 1>>> unit_face_support_points,
- const FullMatrix<double> & interface_constraints)
+ const FullMatrix<double> &interface_constraints)
: dealii::FE_Poly<dim, spacedim>(
polynomials,
fe_data,
void
FE_SimplexPoly<dim, spacedim>::get_face_interpolation_matrix(
const FiniteElement<dim, spacedim> &source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
Assert(interpolation_matrix.m() == source_fe.n_dofs_per_face(face_no),
FE_SimplexPoly<dim, spacedim>::get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &source_fe,
const unsigned int subface,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
Assert(interpolation_matrix.m() == source_fe.n_dofs_per_face(face_no),
FE_SimplexPoly<dim, spacedim>::
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
AssertDimension(support_point_values.size(),
this->get_unit_support_points().size());
const FESystem<dim, spacedim> &fe,
const unsigned int base_no,
const UpdateFlags base_flags,
- const Table<2, unsigned int> & base_to_system_table,
+ const Table<2, unsigned int> &base_to_system_table,
const FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
&base_data,
FEValuesImplementation::FiniteElementRelatedData<dim, spacedim>
template <int dim, int spacedim>
FESystem<dim, spacedim>::FESystem(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities)
+ const std::vector<unsigned int> &multiplicities)
: FiniteElement<dim, spacedim>(
FETools::Compositing::multiply_dof_numbers(fes, multiplicities),
FETools::Compositing::compute_restriction_is_additive_flags(
template <int dim, int spacedim>
double
FESystem<dim, spacedim>::shape_value(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
Assert(this->is_primitive(i),
double
FESystem<dim, spacedim>::shape_value_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
template <int dim, int spacedim>
Tensor<1, dim>
FESystem<dim, spacedim>::shape_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
Assert(this->is_primitive(i),
Tensor<1, dim>
FESystem<dim, spacedim>::shape_grad_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
template <int dim, int spacedim>
Tensor<2, dim>
FESystem<dim, spacedim>::shape_grad_grad(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
Assert(this->is_primitive(i),
Tensor<2, dim>
FESystem<dim, spacedim>::shape_grad_grad_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
template <int dim, int spacedim>
Tensor<3, dim>
FESystem<dim, spacedim>::shape_3rd_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
Assert(this->is_primitive(i),
Tensor<3, dim>
FESystem<dim, spacedim>::shape_3rd_derivative_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
template <int dim, int spacedim>
Tensor<4, dim>
FESystem<dim, spacedim>::shape_4th_derivative(const unsigned int i,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
Assert(this->is_primitive(i),
Tensor<4, dim>
FESystem<dim, spacedim>::shape_4th_derivative_component(
const unsigned int i,
- const Point<dim> & p,
+ const Point<dim> &p,
const unsigned int component) const
{
AssertIndexRange(i, this->n_dofs_per_cell());
void
FESystem<dim, spacedim>::get_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix) const
+ FullMatrix<double> &interpolation_matrix) const
{
// check that the size of the matrices is correct. for historical
// reasons, if you call matrix.reinit(8,0), it sets the sizes
FESystem<dim, spacedim>::get_data(
const UpdateFlags flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
& /*output_data*/) const
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
FESystem<dim, spacedim>::get_face_data(
const UpdateFlags flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const hp::QCollection<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
FESystem<dim, spacedim>::get_subface_data(
const UpdateFlags flags,
const Mapping<dim, spacedim> &mapping,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
& /*output_data*/) const
FESystem<dim, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const Quadrature<dim> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
FESystem<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const hp::QCollection<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Quadrature<dim - 1> & quadrature,
- const Mapping<dim, spacedim> & mapping,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const Quadrature<dim - 1> &quadrature,
+ const Mapping<dim, spacedim> &mapping,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
- & mapping_data,
+ &mapping_data,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
spacedim>
template <class Q_or_QC>
void
FESystem<dim, spacedim>::compute_fill(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const Q_or_QC & quadrature,
+ const Q_or_QC &quadrature,
const CellSimilarity::Similarity cell_similarity,
- const typename Mapping<dim, spacedim>::InternalDataBase & mapping_internal,
+ const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
const internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&mapping_data,
// If we have mixed meshes we need to support a QCollection here, hence
// this pointer casting workaround:
- const Quadrature<dim> * cell_quadrature = nullptr;
+ const Quadrature<dim> *cell_quadrature = nullptr;
const hp::QCollection<dim - 1> *face_quadrature = nullptr;
- const Quadrature<dim - 1> * sub_face_quadrature = nullptr;
+ const Quadrature<dim - 1> *sub_face_quadrature = nullptr;
unsigned int n_q_points = numbers::invalid_unsigned_int;
// static cast through the common base class:
// then come the 12 sets of line indices
if (m < 5 * this->n_dofs_per_vertex() +
12 * this->n_dofs_per_line())
- {
- // for the meaning of all this, see the 2d part
- const unsigned int index_in_line =
- (m - 5 * this->n_dofs_per_vertex()) %
- this->n_dofs_per_line();
- const unsigned int sub_line =
- (m - 5 * this->n_dofs_per_vertex()) /
- this->n_dofs_per_line();
- Assert(sub_line < 12, ExcInternalError());
-
- const unsigned int tmp1 =
- 4 * this->n_dofs_per_vertex() + index_in_line;
- m_index.first =
- this->face_system_to_base_table[face_no][tmp1].first;
-
- Assert(
- this->face_system_to_base_table[face_no][tmp1].second >=
+ {
+ // for the meaning of all this, see the 2d part
+ const unsigned int index_in_line =
+ (m - 5 * this->n_dofs_per_vertex()) %
+ this->n_dofs_per_line();
+ const unsigned int sub_line =
+ (m - 5 * this->n_dofs_per_vertex()) /
+ this->n_dofs_per_line();
+ Assert(sub_line < 12, ExcInternalError());
+
+ const unsigned int tmp1 =
+ 4 * this->n_dofs_per_vertex() + index_in_line;
+ m_index.first =
+ this->face_system_to_base_table[face_no][tmp1].first;
+
+ Assert(
+ this->face_system_to_base_table[face_no][tmp1].second >=
+ 4 * base_element(m_index.first.first)
+ .n_dofs_per_vertex(),
+ ExcInternalError());
+ const unsigned int tmp2 =
+ this->face_system_to_base_table[face_no][tmp1].second -
4 *
- base_element(m_index.first.first).n_dofs_per_vertex(),
- ExcInternalError());
- const unsigned int tmp2 =
- this->face_system_to_base_table[face_no][tmp1].second -
- 4 * base_element(m_index.first.first).n_dofs_per_vertex();
- Assert(tmp2 < base_element(m_index.first.first)
- .n_dofs_per_line(),
- ExcInternalError());
- m_index.second =
- 5 *
- base_element(m_index.first.first).n_dofs_per_vertex() +
- base_element(m_index.first.first).n_dofs_per_line() *
- sub_line +
- tmp2;
- }
- else
- // on one of the four sub-quads
- {
- // for the meaning of all this, see the 2d part
- const unsigned int index_in_quad =
- (m - 5 * this->n_dofs_per_vertex() -
- 12 * this->n_dofs_per_line()) %
- this->n_dofs_per_quad(face_no);
- Assert(index_in_quad < this->n_dofs_per_quad(face_no),
- ExcInternalError());
- const unsigned int sub_quad =
- ((m - 5 * this->n_dofs_per_vertex() -
- 12 * this->n_dofs_per_line()) /
- this->n_dofs_per_quad(face_no));
- Assert(sub_quad < 4, ExcInternalError());
-
- const unsigned int tmp1 = 4 * this->n_dofs_per_vertex() +
- 4 * this->n_dofs_per_line() +
- index_in_quad;
- Assert(tmp1 <
- this->face_system_to_base_table[face_no].size(),
- ExcInternalError());
- m_index.first =
- this->face_system_to_base_table[face_no][tmp1].first;
-
- Assert(
- this->face_system_to_base_table[face_no][tmp1].second >=
+ base_element(m_index.first.first).n_dofs_per_vertex();
+ Assert(tmp2 < base_element(m_index.first.first)
+ .n_dofs_per_line(),
+ ExcInternalError());
+ m_index.second =
+ 5 * base_element(m_index.first.first)
+ .n_dofs_per_vertex() +
+ base_element(m_index.first.first).n_dofs_per_line() *
+ sub_line +
+ tmp2;
+ }
+ else
+ // on one of the four sub-quads
+ {
+ // for the meaning of all this, see the 2d part
+ const unsigned int index_in_quad =
+ (m - 5 * this->n_dofs_per_vertex() -
+ 12 * this->n_dofs_per_line()) %
+ this->n_dofs_per_quad(face_no);
+ Assert(index_in_quad < this->n_dofs_per_quad(face_no),
+ ExcInternalError());
+ const unsigned int sub_quad =
+ ((m - 5 * this->n_dofs_per_vertex() -
+ 12 * this->n_dofs_per_line()) /
+ this->n_dofs_per_quad(face_no));
+ Assert(sub_quad < 4, ExcInternalError());
+
+ const unsigned int tmp1 = 4 * this->n_dofs_per_vertex() +
+ 4 * this->n_dofs_per_line() +
+ index_in_quad;
+ Assert(tmp1 <
+ this->face_system_to_base_table[face_no].size(),
+ ExcInternalError());
+ m_index.first =
+ this->face_system_to_base_table[face_no][tmp1].first;
+
+ Assert(
+ this->face_system_to_base_table[face_no][tmp1].second >=
+ 4 * base_element(m_index.first.first)
+ .n_dofs_per_vertex() +
+ 4 * base_element(m_index.first.first)
+ .n_dofs_per_line(),
+ ExcInternalError());
+ const unsigned int tmp2 =
+ this->face_system_to_base_table[face_no][tmp1].second -
4 * base_element(m_index.first.first)
+ .n_dofs_per_vertex() -
+ 4 * base_element(m_index.first.first).n_dofs_per_line();
+ Assert(tmp2 < base_element(m_index.first.first)
+ .n_dofs_per_quad(face_no),
+ ExcInternalError());
+ m_index.second =
+ 5 * base_element(m_index.first.first)
.n_dofs_per_vertex() +
- 4 *
- base_element(m_index.first.first).n_dofs_per_line(),
- ExcInternalError());
- const unsigned int tmp2 =
- this->face_system_to_base_table[face_no][tmp1].second -
- 4 *
- base_element(m_index.first.first).n_dofs_per_vertex() -
- 4 * base_element(m_index.first.first).n_dofs_per_line();
- Assert(tmp2 < base_element(m_index.first.first)
- .n_dofs_per_quad(face_no),
- ExcInternalError());
- m_index.second =
- 5 *
- base_element(m_index.first.first).n_dofs_per_vertex() +
- 12 * base_element(m_index.first.first).n_dofs_per_line() +
- base_element(m_index.first.first)
- .n_dofs_per_quad(face_no) *
- sub_quad +
- tmp2;
- }
+ 12 *
+ base_element(m_index.first.first).n_dofs_per_line() +
+ base_element(m_index.first.first)
+ .n_dofs_per_quad(face_no) *
+ sub_quad +
+ tmp2;
+ }
break;
}
void
FESystem<dim, spacedim>::initialize(
const std::vector<const FiniteElement<dim, spacedim> *> &fes,
- const std::vector<unsigned int> & multiplicities)
+ const std::vector<unsigned int> &multiplicities)
{
Assert(fes.size() == multiplicities.size(),
ExcDimensionMismatch(fes.size(), multiplicities.size()));
void
FESystem<dim, spacedim>::get_face_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
Assert(interpolation_matrix.n() == this->n_dofs_per_face(face_no),
FESystem<dim, spacedim>::get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
const unsigned int subface,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
AssertThrow(
void
FESystem<dim, spacedim>::convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &point_values,
- std::vector<double> & dof_values) const
+ std::vector<double> &dof_values) const
{
Assert(this->has_generalized_support_points(),
ExcMessage("The FESystem does not have generalized support points"));
// We need access to the base_element, its multiplicity, the
// number of generalized support points (n_base_points) and the
// number of components we're dealing with.
- const auto & base_element = this->base_element(base);
+ const auto &base_element = this->base_element(base);
const unsigned int multiplicity = this->element_multiplicity(base);
const unsigned int n_base_dofs = base_element.n_dofs_per_cell();
const unsigned int n_base_components = base_element.n_components();
multiply_dof_numbers(
const std::vector<
const FiniteElement<deal_II_dimension, deal_II_space_dimension> *>
- & fes,
+ &fes,
const std::vector<unsigned int> &multiplicities,
bool);
compute_restriction_is_additive_flags(
const std::vector<
const FiniteElement<deal_II_dimension, deal_II_space_dimension> *>
- & fes,
+ &fes,
const std::vector<unsigned int> &multiplicities);
template std::vector<bool>
compute_nonzero_components(
const std::vector<
const FiniteElement<deal_II_dimension, deal_II_space_dimension> *>
- & fes,
+ &fes,
const std::vector<unsigned int> &multiplicities,
const bool do_tensor_product);
std::vector<std::pair<std::pair<unsigned int, unsigned int>,
unsigned int>> &system_to_base_table,
std::vector<std::pair<unsigned int, unsigned int>>
- & system_to_component_table,
+ &system_to_component_table,
std::vector<std::pair<std::pair<unsigned int, unsigned int>,
unsigned int>> &component_to_base_table,
const FiniteElement<deal_II_dimension, deal_II_space_dimension> &fe,
FE_TraceQ<dim, spacedim>::
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
AssertDimension(support_point_values.size(),
this->get_unit_support_points().size());
void
FE_TraceQ<dim, spacedim>::get_face_interpolation_matrix(
const FiniteElement<dim, spacedim> &source_fe,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
get_subface_interpolation_matrix(source_fe,
FE_TraceQ<dim, spacedim>::get_subface_interpolation_matrix(
const FiniteElement<dim, spacedim> &x_source_fe,
const unsigned int subface,
- FullMatrix<double> & interpolation_matrix,
+ FullMatrix<double> &interpolation_matrix,
const unsigned int face_no) const
{
// this is the code from FE_FaceQ
template <int dim, int spacedim>
-FEValues<dim, spacedim>::FEValues(const Mapping<dim, spacedim> & mapping,
+FEValues<dim, spacedim>::FEValues(const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & q,
+ const Quadrature<dim> &q,
const UpdateFlags update_flags)
: FEValuesBase<dim, spacedim>(q.size(),
fe.n_dofs_per_cell(),
template <int dim, int spacedim>
-FEValues<dim, spacedim>::FEValues(const Mapping<dim, spacedim> & mapping,
+FEValues<dim, spacedim>::FEValues(const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim> & q,
+ const hp::QCollection<dim> &q,
const UpdateFlags update_flags)
: FEValues(mapping, fe, q[0], update_flags)
{
template <int dim, int spacedim>
FEValues<dim, spacedim>::FEValues(const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & q,
+ const Quadrature<dim> &q,
const UpdateFlags update_flags)
: FEValuesBase<dim, spacedim>(
q.size(),
template <int dim, int spacedim>
FEValues<dim, spacedim>::FEValues(const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim> & q,
+ const hp::QCollection<dim> &q,
const UpdateFlags update_flags)
: FEValues(fe, q[0], update_flags)
{
FEFaceValuesBase<dim, spacedim>::FEFaceValuesBase(
const unsigned int dofs_per_cell,
const UpdateFlags flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature)
+ const Quadrature<dim - 1> &quadrature)
: FEFaceValuesBase<dim, spacedim>(dofs_per_cell,
flags,
mapping,
FEFaceValuesBase<dim, spacedim>::FEFaceValuesBase(
const unsigned int dofs_per_cell,
const UpdateFlags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & quadrature)
+ const hp::QCollection<dim - 1> &quadrature)
: FEValuesBase<dim, spacedim>(quadrature.max_n_quadrature_points(),
dofs_per_cell,
update_default,
template <int dim, int spacedim>
FEFaceValues<dim, spacedim>::FEFaceValues(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const UpdateFlags update_flags)
: FEFaceValues<dim, spacedim>(mapping,
fe,
template <int dim, int spacedim>
FEFaceValues<dim, spacedim>::FEFaceValues(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const UpdateFlags update_flags)
: FEFaceValuesBase<dim, spacedim>(fe.n_dofs_per_cell(),
update_flags,
template <int dim, int spacedim>
FEFaceValues<dim, spacedim>::FEFaceValues(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const UpdateFlags update_flags)
: FEFaceValues<dim, spacedim>(fe,
hp::QCollection<dim - 1>(quadrature),
template <int dim, int spacedim>
FEFaceValues<dim, spacedim>::FEFaceValues(
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const UpdateFlags update_flags)
: FEFaceValuesBase<dim, spacedim>(
fe.n_dofs_per_cell(),
template <bool lda>
void
FEFaceValues<dim, spacedim>::reinit(
- const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> & cell,
+ const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &cell,
const typename Triangulation<dim, spacedim>::face_iterator &face)
{
const auto face_n = cell->face_iterator_to_index(face);
template <int dim, int spacedim>
FESubfaceValues<dim, spacedim>::FESubfaceValues(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const UpdateFlags update_flags)
: FEFaceValuesBase<dim, spacedim>(fe.n_dofs_per_cell(),
update_flags,
template <int dim, int spacedim>
FESubfaceValues<dim, spacedim>::FESubfaceValues(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const UpdateFlags update_flags)
: FESubfaceValues(mapping, fe, quadrature[0], update_flags)
{
template <int dim, int spacedim>
FESubfaceValues<dim, spacedim>::FESubfaceValues(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const UpdateFlags update_flags)
: FEFaceValuesBase<dim, spacedim>(
fe.n_dofs_per_cell(),
template <int dim, int spacedim>
FESubfaceValues<dim, spacedim>::FESubfaceValues(
const FiniteElement<dim, spacedim> &fe,
- const hp::QCollection<dim - 1> & quadrature,
+ const hp::QCollection<dim - 1> &quadrature,
const UpdateFlags update_flags)
: FESubfaceValues(fe, quadrature[0], update_flags)
{
template <bool lda>
void
FESubfaceValues<dim, spacedim>::reinit(
- const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> & cell,
+ const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &cell,
const typename Triangulation<dim, spacedim>::face_iterator &face,
const typename Triangulation<dim, spacedim>::face_iterator &subface)
{
void
FEValuesBase<dim, spacedim>::CellIteratorContainer::get_interpolated_dof_values(
const ReadVector<Number> &in,
- Vector<Number> & out) const
+ Vector<Number> &out) const
{
Assert(is_initialized(), ExcNotReinited());
Assert(dof_handler != nullptr, ExcNeedsDoFHandler());
template <int dim, int spacedim>
void
FEValuesBase<dim, spacedim>::CellIteratorContainer::get_interpolated_dof_values(
- const IndexSet & in,
+ const IndexSet &in,
Vector<IndexSet::value_type> &out) const
{
Assert(is_initialized(), ExcNotReinited());
const unsigned int n_q_points,
const unsigned int dofs_per_cell,
const UpdateFlags flags,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe)
: n_quadrature_points(n_q_points)
, max_n_quadrature_points(n_q_points)
template <typename Number, typename Number2>
void
- do_function_values(const ArrayView<Number2> & dof_values,
+ do_function_values(const ArrayView<Number2> &dof_values,
const dealii::Table<2, double> &shape_values,
- std::vector<Number> & values)
+ std::vector<Number> &values)
{
// scalar finite elements, so shape_values.size() == dofs_per_cell
const unsigned int dofs_per_cell = shape_values.n_rows();
void
do_function_values(
const ArrayView<typename VectorType::value_type> &dof_values,
- const dealii::Table<2, double> & shape_values,
- const FiniteElement<dim, spacedim> & fe,
+ const dealii::Table<2, double> &shape_values,
+ const FiniteElement<dim, spacedim> &fe,
const std::vector<unsigned int> &shape_function_to_row_table,
ArrayView<VectorType> values,
const bool quadrature_points_fastest = false,
const unsigned int row =
shape_function_to_row_table[shape_func * n_components + c];
- const double * shape_value_ptr = &shape_values(row, 0);
+ const double *shape_value_ptr = &shape_values(row, 0);
const unsigned int comp = c + mc * n_components;
if (quadrature_points_fastest)
template <int order, int spacedim, typename Number>
void
do_function_derivatives(
- const ArrayView<Number> & dof_values,
+ const ArrayView<Number> &dof_values,
const dealii::Table<2, Tensor<order, spacedim>> &shape_derivatives,
- std::vector<Tensor<order, spacedim, Number>> & derivatives)
+ std::vector<Tensor<order, spacedim, Number>> &derivatives)
{
const unsigned int dofs_per_cell = shape_derivatives.size()[0];
const unsigned int n_quadrature_points = derivatives.size();
template <int order, int dim, int spacedim, typename Number>
void
do_function_derivatives(
- const ArrayView<Number> & dof_values,
+ const ArrayView<Number> &dof_values,
const dealii::Table<2, Tensor<order, spacedim>> &shape_derivatives,
- const FiniteElement<dim, spacedim> & fe,
+ const FiniteElement<dim, spacedim> &fe,
const std::vector<unsigned int> &shape_function_to_row_table,
ArrayView<std::vector<Tensor<order, spacedim, Number>>> derivatives,
const bool quadrature_points_fastest = false,
template <int spacedim, typename Number, typename Number2>
void
do_function_laplacians(
- const ArrayView<Number2> & dof_values,
+ const ArrayView<Number2> &dof_values,
const dealii::Table<2, Tensor<2, spacedim>> &shape_hessians,
- std::vector<Number> & laplacians)
+ std::vector<Number> &laplacians)
{
const unsigned int dofs_per_cell = shape_hessians.size()[0];
const unsigned int n_quadrature_points = laplacians.size();
template <int dim, int spacedim, typename VectorType, typename Number>
void
do_function_laplacians(
- const ArrayView<Number> & dof_values,
+ const ArrayView<Number> &dof_values,
const dealii::Table<2, Tensor<2, spacedim>> &shape_hessians,
- const FiniteElement<dim, spacedim> & fe,
- const std::vector<unsigned int> & shape_function_to_row_table,
- std::vector<VectorType> & laplacians,
+ const FiniteElement<dim, spacedim> &fe,
+ const std::vector<unsigned int> &shape_function_to_row_table,
+ std::vector<VectorType> &laplacians,
const bool quadrature_points_fastest = false,
const unsigned int component_multiple = 1)
{
void
FEValuesBase<dim, spacedim>::get_function_values(
const ReadVector<Number> &fe_function,
- std::vector<Number> & values) const
+ std::vector<Number> &values) const
{
Assert(this->update_flags & update_values,
ExcAccessToUninitializedField("update_values"));
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_values(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Number> & values) const
+ std::vector<Number> &values) const
{
Assert(this->update_flags & update_values,
ExcAccessToUninitializedField("update_values"));
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_values(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<Vector<Number>> &values) const
{
Assert(present_cell.is_initialized(), ExcNotReinited());
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_values(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Vector<Number>> & values) const
+ std::vector<Vector<Number>> &values) const
{
// Size of indices must be a multiple of dofs_per_cell such that an integer
// number of function values is generated in each point.
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_values(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
ArrayView<std::vector<Number>> values,
const bool quadrature_points_fastest) const
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<Tensor<1, spacedim, Number>> &gradients) const
{
Assert(this->update_flags & update_gradients,
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Tensor<1, spacedim, Number>> & gradients) const
+ std::vector<Tensor<1, spacedim, Number>> &gradients) const
{
Assert(this->update_flags & update_gradients,
ExcAccessToUninitializedField("update_gradients"));
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<std::vector<Tensor<1, spacedim, Number>>> &gradients) const
{
Assert(this->update_flags & update_gradients,
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_gradients(
- const ReadVector<Number> & fe_function,
- const ArrayView<const types::global_dof_index> & indices,
+ const ReadVector<Number> &fe_function,
+ const ArrayView<const types::global_dof_index> &indices,
ArrayView<std::vector<Tensor<1, spacedim, Number>>> gradients,
const bool quadrature_points_fastest) const
{
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_hessians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<Tensor<2, spacedim, Number>> &hessians) const
{
AssertDimension(fe->n_components(), 1);
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_hessians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Tensor<2, spacedim, Number>> & hessians) const
+ std::vector<Tensor<2, spacedim, Number>> &hessians) const
{
Assert(this->update_flags & update_hessians,
ExcAccessToUninitializedField("update_hessians"));
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_hessians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<std::vector<Tensor<2, spacedim, Number>>> &hessians,
const bool quadrature_points_fastest) const
{
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_hessians(
- const ReadVector<Number> & fe_function,
- const ArrayView<const types::global_dof_index> & indices,
+ const ReadVector<Number> &fe_function,
+ const ArrayView<const types::global_dof_index> &indices,
ArrayView<std::vector<Tensor<2, spacedim, Number>>> hessians,
const bool quadrature_points_fastest) const
{
void
FEValuesBase<dim, spacedim>::get_function_laplacians(
const ReadVector<Number> &fe_function,
- std::vector<Number> & laplacians) const
+ std::vector<Number> &laplacians) const
{
Assert(this->update_flags & update_hessians,
ExcAccessToUninitializedField("update_hessians"));
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_laplacians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Number> & laplacians) const
+ std::vector<Number> &laplacians) const
{
Assert(this->update_flags & update_hessians,
ExcAccessToUninitializedField("update_hessians"));
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_laplacians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<Vector<Number>> &laplacians) const
{
Assert(present_cell.is_initialized(), ExcNotReinited());
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_laplacians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Vector<Number>> & laplacians) const
+ std::vector<Vector<Number>> &laplacians) const
{
// Size of indices must be a multiple of dofs_per_cell such that an integer
// number of function values is generated in each point.
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_laplacians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<std::vector<Number>> & laplacians,
+ std::vector<std::vector<Number>> &laplacians,
const bool quadrature_points_fastest) const
{
Assert(indices.size() % dofs_per_cell == 0,
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<Tensor<3, spacedim, Number>> &third_derivatives) const
{
AssertDimension(fe->n_components(), 1);
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
const ArrayView<const types::global_dof_index> &indices,
- std::vector<Tensor<3, spacedim, Number>> & third_derivatives) const
+ std::vector<Tensor<3, spacedim, Number>> &third_derivatives) const
{
Assert(this->update_flags & update_3rd_derivatives,
ExcAccessToUninitializedField("update_3rd_derivatives"));
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<std::vector<Tensor<3, spacedim, Number>>> &third_derivatives,
const bool quadrature_points_fastest) const
{
template <typename Number>
void
FEValuesBase<dim, spacedim>::get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
- const ArrayView<const types::global_dof_index> & indices,
+ const ReadVector<Number> &fe_function,
+ const ArrayView<const types::global_dof_index> &indices,
ArrayView<std::vector<Tensor<3, spacedim, Number>>> third_derivatives,
const bool quadrature_points_fastest) const
{
// in MappingQ, data can have been modified during the last call. Then, we
// can't use that data on the new cell.
if (cell_similarity == CellSimilarity::invalid_next_cell)
- cell_similarity = CellSimilarity::none;
- else
- cell_similarity =
- (cell->is_translation_of(
- static_cast<const typename Triangulation<dim, spacedim>::cell_iterator
- &>(this->present_cell)) ?
- CellSimilarity::translation :
- CellSimilarity::none);
+ cell_similarity = CellSimilarity::none;
+ else
+ cell_similarity =
+ (cell->is_translation_of(
+ static_cast<
+ const typename Triangulation<dim, spacedim>::cell_iterator &>(
+ this->present_cell)) ?
+ CellSimilarity::translation :
+ CellSimilarity::none);
if ((dim < spacedim) && (cell_similarity == CellSimilarity::translation))
{
template <typename Number>
void
Scalar<dim, spacedim>::get_function_values(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_value_type<Number>> &values) const
{
Assert(fe_values->update_flags & update_values,
template <typename Number>
void
Scalar<dim, spacedim>::get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_gradient_type<Number>> &gradients) const
{
Assert(fe_values->update_flags & update_gradients,
template <typename Number>
void
Scalar<dim, spacedim>::get_function_hessians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_hessian_type<Number>> &hessians) const
{
Assert(fe_values->update_flags & update_hessians,
template <typename Number>
void
Scalar<dim, spacedim>::get_function_laplacians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_laplacian_type<Number>> &laplacians) const
{
Assert(fe_values->update_flags & update_hessians,
template <typename Number>
void
Scalar<dim, spacedim>::get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_third_derivative_type<Number>> &third_derivatives)
const
{
template <typename Number>
void
Vector<dim, spacedim>::get_function_values(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_value_type<Number>> &values) const
{
Assert(fe_values->update_flags & update_values,
template <typename Number>
void
Vector<dim, spacedim>::get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_gradient_type<Number>> &gradients) const
{
Assert(fe_values->update_flags & update_gradients,
template <typename Number>
void
Vector<dim, spacedim>::get_function_symmetric_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_symmetric_gradient_type<Number>> &symmetric_gradients)
const
{
template <typename Number>
void
Vector<dim, spacedim>::get_function_divergences(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_divergence_type<Number>> &divergences) const
{
Assert(fe_values->update_flags & update_gradients,
template <typename Number>
void
Vector<dim, spacedim>::get_function_curls(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_curl_type<Number>> &curls) const
{
Assert(fe_values->update_flags & update_gradients,
template <typename Number>
void
Vector<dim, spacedim>::get_function_hessians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_hessian_type<Number>> &hessians) const
{
Assert(fe_values->update_flags & update_hessians,
template <typename Number>
void
Vector<dim, spacedim>::get_function_laplacians(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_value_type<Number>> &laplacians) const
{
Assert(fe_values->update_flags & update_hessians,
template <typename Number>
void
Vector<dim, spacedim>::get_function_third_derivatives(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_third_derivative_type<Number>> &third_derivatives)
const
{
template <typename Number>
void
SymmetricTensor<2, dim, spacedim>::get_function_values(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_value_type<Number>> &values) const
{
Assert(fe_values->update_flags & update_values,
template <typename Number>
void
SymmetricTensor<2, dim, spacedim>::get_function_divergences(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_divergence_type<Number>> &divergences) const
{
Assert(fe_values->update_flags & update_gradients,
template <typename Number>
void
Tensor<2, dim, spacedim>::get_function_values(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_value_type<Number>> &values) const
{
Assert(fe_values->update_flags & update_values,
template <typename Number>
void
Tensor<2, dim, spacedim>::get_function_divergences(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_divergence_type<Number>> &divergences) const
{
Assert(fe_values->update_flags & update_gradients,
template <typename Number>
void
Tensor<2, dim, spacedim>::get_function_gradients(
- const ReadVector<Number> & fe_function,
+ const ReadVector<Number> &fe_function,
std::vector<solution_gradient_type<Number>> &gradients) const
{
Assert(fe_values->update_flags & update_gradients,
void
do_function_values(
const ArrayView<const Number> &dof_values,
- const Table<2, double> & shape_values,
+ const Table<2, double> &shape_values,
const std::vector<typename Scalar<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
std::vector<typename ProductType<Number, double>::type> &values)
template <int order, int dim, int spacedim, typename Number>
void
do_function_derivatives(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<order, spacedim>> &shape_derivatives,
const std::vector<typename Scalar<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_laplacians(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<2, spacedim>> &shape_hessians,
const std::vector<typename Scalar<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
void
do_function_values(
const ArrayView<const Number> &dof_values,
- const Table<2, double> & shape_values,
+ const Table<2, double> &shape_values,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
std::vector<
template <int order, int dim, int spacedim, typename Number>
void
do_function_derivatives(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<order, spacedim>> &shape_derivatives,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_symmetric_gradients(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_divergences(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_curls(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_laplacians(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<2, spacedim>> &shape_hessians,
const std::vector<typename Vector<dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_values(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const dealii::Table<2, double> &shape_values,
const std::vector<
typename SymmetricTensor<2, dim, spacedim>::ShapeFunctionData>
template <int dim, int spacedim, typename Number>
void
do_function_divergences(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<
typename SymmetricTensor<2, dim, spacedim>::ShapeFunctionData>
template <int dim, int spacedim, typename Number>
void
do_function_values(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const dealii::Table<2, double> &shape_values,
const std::vector<typename Tensor<2, dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_divergences(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<typename Tensor<2, dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim, typename Number>
void
do_function_gradients(
- const ArrayView<const Number> & dof_values,
+ const ArrayView<const Number> &dof_values,
const Table<2, dealii::Tensor<1, spacedim>> &shape_gradients,
const std::vector<typename Tensor<2, dim, spacedim>::ShapeFunctionData>
&shape_function_data,
template <int dim, int spacedim>
FE_WedgePoly<dim, spacedim>::FE_WedgePoly(
const unsigned int degree,
- const internal::GenericDoFsPerObject & dpos,
+ const internal::GenericDoFsPerObject &dpos,
const typename FiniteElementData<dim>::Conformity conformity)
: dealii::FE_Poly<dim, spacedim>(
ScalarLagrangePolynomialWedge<dim>(degree),
FE_WedgePoly<dim, spacedim>::
convert_generalized_support_point_values_to_dof_values(
const std::vector<Vector<double>> &support_point_values,
- std::vector<double> & nodal_values) const
+ std::vector<double> &nodal_values) const
{
AssertDimension(support_point_values.size(),
this->get_unit_support_points().size());
void
Mapping<dim, spacedim>::transform_points_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const ArrayView<const Point<spacedim>> & real_points,
- const ArrayView<Point<dim>> & unit_points) const
+ const ArrayView<const Point<spacedim>> &real_points,
+ const ArrayView<Point<dim>> &unit_points) const
{
AssertDimension(real_points.size(), unit_points.size());
for (unsigned int i = 0; i < real_points.size(); ++i)
Mapping<dim, spacedim>::project_real_point_to_unit_point_on_face(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const Point<spacedim> & p) const
+ const Point<spacedim> &p) const
{
// The function doesn't make physical sense for dim=1
Assert(dim > 1, ExcNotImplemented());
Mapping<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
Mapping<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
#if deal_II_dimension <= deal_II_space_dimension
template class Mapping<deal_II_dimension, deal_II_space_dimension>;
- template const Mapping<deal_II_dimension, deal_II_space_dimension>
- &get_default_linear_mapping(
- const Triangulation<deal_II_dimension, deal_II_space_dimension>
- &triangulation);
+ template const Mapping<deal_II_dimension, deal_II_space_dimension> &
+ get_default_linear_mapping(
+ const Triangulation<deal_II_dimension, deal_II_space_dimension>
+ &triangulation);
#endif
}
void
MappingC1<2>::add_line_support_points(
const Triangulation<2>::cell_iterator &cell,
- std::vector<Point<2>> & a) const
+ std::vector<Point<2>> &a) const
{
const unsigned int dim = 2;
const std::array<double, 2> interior_gl_points{
const double abs_tol = 1e-30;
const double rel_tol = 1e-28;
const auto bounding_box = cell->bounding_box();
- const auto & bounding_vertices = bounding_box.get_boundary_points();
+ const auto &bounding_vertices = bounding_box.get_boundary_points();
const auto bb_diagonal_length_squared =
bounding_vertices.first.distance_square(bounding_vertices.second);
MappingCartesian<dim, spacedim>::update_cell_extents(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const InternalData & data) const
+ const InternalData &data) const
{
// Compute start point and sizes
// along axes. Strange vertex
void
MappingCartesian<dim, spacedim>::maybe_update_cell_quadrature_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const InternalData & data,
+ const InternalData &data,
std::vector<Point<dim>> &quadrature_points) const
{
if (data.update_each & update_quadrature_points)
MappingCartesian<dim, spacedim>::maybe_update_face_quadrature_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const InternalData & data,
+ const InternalData &data,
std::vector<Point<dim>> &quadrature_points) const
{
AssertIndexRange(face_no, GeometryInfo<dim>::faces_per_cell);
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int sub_no,
- const InternalData & data,
+ const InternalData &data,
std::vector<Point<dim>> &quadrature_points) const
{
AssertIndexRange(face_no, GeometryInfo<dim>::faces_per_cell);
void
MappingCartesian<dim, spacedim>::transform_quadrature_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const InternalData & data,
- const typename QProjector<dim>::DataSetDescriptor & offset,
+ const InternalData &data,
+ const typename QProjector<dim>::DataSetDescriptor &offset,
std::vector<Point<dim>> &quadrature_points) const
{
// let @p{start} be the origin of a local coordinate system. it is chosen
void
MappingCartesian<dim, spacedim>::maybe_update_normal_vectors(
const unsigned int face_no,
- const InternalData & data,
+ const InternalData &data,
std::vector<Tensor<1, dim>> &normal_vectors) const
{
// compute normal vectors. All normals on a face have the same value.
template <int dim, int spacedim>
void
MappingCartesian<dim, spacedim>::maybe_update_jacobian_derivatives(
- const InternalData & data,
+ const InternalData &data,
const CellSimilarity::Similarity cell_similarity,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
template <int dim, int spacedim>
void
MappingCartesian<dim, spacedim>::maybe_update_jacobians(
- const InternalData & data,
+ const InternalData &data,
const CellSimilarity::Similarity cell_similarity,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
template <int dim, int spacedim>
void
MappingCartesian<dim, spacedim>::maybe_update_inverse_jacobians(
- const InternalData & data,
+ const InternalData &data,
const CellSimilarity::Similarity cell_similarity,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
MappingCartesian<dim, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
void
MappingCartesian<dim, spacedim>::fill_mapping_data_for_generic_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const ArrayView<const Point<dim>> & unit_points,
+ const ArrayView<const Point<dim>> &unit_points,
const UpdateFlags update_flags,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
MappingCartesian<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
void
MappingCartesian<dim, spacedim>::fill_fe_immersed_surface_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const NonMatching::ImmersedSurfaceQuadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const NonMatching::ImmersedSurfaceQuadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
template <int dim, int spacedim>
void
MappingCartesian<dim, spacedim>::transform(
- const ArrayView<const Tensor<1, dim>> & input,
+ const ArrayView<const Tensor<1, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<1, spacedim>> & output) const
+ const ArrayView<Tensor<1, spacedim>> &output) const
{
AssertDimension(input.size(), output.size());
Assert(dynamic_cast<const InternalData *>(&mapping_data) != nullptr,
const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<2, spacedim>> & output) const
+ const ArrayView<Tensor<2, spacedim>> &output) const
{
AssertDimension(input.size(), output.size());
Assert(dynamic_cast<const InternalData *>(&mapping_data) != nullptr,
template <int dim, int spacedim>
void
MappingCartesian<dim, spacedim>::transform(
- const ArrayView<const Tensor<2, dim>> & input,
+ const ArrayView<const Tensor<2, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<2, spacedim>> & output) const
+ const ArrayView<Tensor<2, spacedim>> &output) const
{
AssertDimension(input.size(), output.size());
Assert(dynamic_cast<const InternalData *>(&mapping_data) != nullptr,
const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output) const
+ const ArrayView<Tensor<3, spacedim>> &output) const
{
AssertDimension(input.size(), output.size());
Assert(dynamic_cast<const InternalData *>(&mapping_data) != nullptr,
template <int dim, int spacedim>
void
MappingCartesian<dim, spacedim>::transform(
- const ArrayView<const Tensor<3, dim>> & input,
+ const ArrayView<const Tensor<3, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output) const
+ const ArrayView<Tensor<3, spacedim>> &output) const
{
AssertDimension(input.size(), output.size());
Assert(dynamic_cast<const InternalData *>(&mapping_data) != nullptr,
Point<spacedim>
MappingCartesian<dim, spacedim>::transform_unit_to_real_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
Assert(is_cartesian(cell), ExcCellNotCartesian());
Point<dim>
MappingCartesian<dim, spacedim>::transform_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<spacedim> & p) const
+ const Point<spacedim> &p) const
{
Assert(is_cartesian(cell), ExcCellNotCartesian());
if (update_flags & update_quadrature_points)
for (unsigned int point = 0; point < n_q_points; ++point)
{
- const double * shape = &data.shape(point + data_set, 0);
+ const double *shape = &data.shape(point + data_set, 0);
Point<spacedim> result =
(shape[0] * data.mapping_support_points[0]);
for (unsigned int k = 1; k < data.n_shape_functions; ++k)
const typename QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingFE<dim, spacedim>::InternalData &data,
std::vector<Tensor<4, spacedim>>
- & jacobian_pushed_forward_2nd_derivatives,
+ &jacobian_pushed_forward_2nd_derivatives,
const unsigned int n_q_points)
{
const UpdateFlags update_flags = data.update_each;
const typename QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingFE<dim, spacedim>::InternalData &data,
std::vector<Tensor<5, spacedim>>
- & jacobian_pushed_forward_3rd_derivatives,
+ &jacobian_pushed_forward_3rd_derivatives,
const unsigned int n_q_points)
{
const UpdateFlags update_flags = data.update_each;
Point<spacedim>
MappingFE<dim, spacedim>::transform_unit_to_real_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
const std::vector<Point<spacedim>> support_points =
this->compute_mapping_support_points(cell);
Point<dim>
MappingFE<dim, spacedim>::transform_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<spacedim> & p) const
+ const Point<spacedim> &p) const
{
const std::vector<Point<spacedim>> support_points =
this->compute_mapping_support_points(cell);
MappingFE<dim, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
maybe_compute_face_data(
const dealii::MappingFE<dim, spacedim> &mapping,
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & cell,
+ &cell,
const unsigned int face_no,
const unsigned int subface_no,
const unsigned int n_q_points,
do_fill_fe_face_values(
const dealii::MappingFE<dim, spacedim> &mapping,
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & cell,
+ &cell,
const unsigned int face_no,
const unsigned int subface_no,
const typename QProjector<dim>::DataSetDescriptor data_set,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const typename dealii::MappingFE<dim, spacedim>::InternalData &data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data)
MappingFE<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
template <int dim, int spacedim, int rank>
void
transform_fields(
- const ArrayView<const Tensor<rank, dim>> & input,
+ const ArrayView<const Tensor<rank, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<rank, spacedim>> & output)
+ const ArrayView<Tensor<rank, spacedim>> &output)
{
// In the case of wedges and pyramids, faces might have different
// numbers of quadrature points on each face with the result
template <int dim, int spacedim, int rank>
void
transform_gradients(
- const ArrayView<const Tensor<rank, dim>> & input,
+ const ArrayView<const Tensor<rank, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<rank, spacedim>> & output)
+ const ArrayView<Tensor<rank, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert(
template <int dim, int spacedim>
void
transform_hessians(
- const ArrayView<const Tensor<3, dim>> & input,
+ const ArrayView<const Tensor<3, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output)
+ const ArrayView<Tensor<3, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert(
const ArrayView<const DerivativeForm<rank, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<rank + 1, spacedim>> & output)
+ const ArrayView<Tensor<rank + 1, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert(
template <int dim, int spacedim>
void
MappingFE<dim, spacedim>::transform(
- const ArrayView<const Tensor<1, dim>> & input,
+ const ArrayView<const Tensor<1, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<1, spacedim>> & output) const
+ const ArrayView<Tensor<1, spacedim>> &output) const
{
internal::MappingFEImplementation::transform_fields(input,
mapping_kind,
const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<2, spacedim>> & output) const
+ const ArrayView<Tensor<2, spacedim>> &output) const
{
internal::MappingFEImplementation::transform_differential_forms(input,
mapping_kind,
template <int dim, int spacedim>
void
MappingFE<dim, spacedim>::transform(
- const ArrayView<const Tensor<2, dim>> & input,
+ const ArrayView<const Tensor<2, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<2, spacedim>> & output) const
+ const ArrayView<Tensor<2, spacedim>> &output) const
{
switch (mapping_kind)
{
const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output) const
+ const ArrayView<Tensor<3, spacedim>> &output) const
{
AssertDimension(input.size(), output.size());
Assert(dynamic_cast<const InternalData *>(&mapping_data) != nullptr,
template <int dim, int spacedim>
void
MappingFE<dim, spacedim>::transform(
- const ArrayView<const Tensor<3, dim>> & input,
+ const ArrayView<const Tensor<3, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output) const
+ const ArrayView<Tensor<3, spacedim>> &output) const
{
switch (mapping_kind)
{
template <int dim, int spacedim, typename VectorType>
MappingFEField<dim, spacedim, VectorType>::InternalData::InternalData(
const FiniteElement<dim, spacedim> &fe,
- const ComponentMask & mask)
+ const ComponentMask &mask)
: unit_tangentials()
, n_shape_functions(fe.n_dofs_per_cell())
, mask(mask)
template <int dim, int spacedim, typename VectorType>
MappingFEField<dim, spacedim, VectorType>::MappingFEField(
const DoFHandler<dim, spacedim> &euler_dof_handler,
- const VectorType & euler_vector,
- const ComponentMask & mask)
+ const VectorType &euler_vector,
+ const ComponentMask &mask)
: reference_cell(euler_dof_handler.get_fe().reference_cell())
, uses_level_dofs(false)
, euler_vector({&euler_vector})
template <int dim, int spacedim, typename VectorType>
MappingFEField<dim, spacedim, VectorType>::MappingFEField(
const DoFHandler<dim, spacedim> &euler_dof_handler,
- const std::vector<VectorType> & euler_vector,
- const ComponentMask & mask)
+ const std::vector<VectorType> &euler_vector,
+ const ComponentMask &mask)
: reference_cell(euler_dof_handler.get_fe().reference_cell())
, uses_level_dofs(true)
, euler_dof_handler(&euler_dof_handler)
MappingFEField<dim, spacedim, VectorType>::MappingFEField(
const DoFHandler<dim, spacedim> &euler_dof_handler,
const MGLevelObject<VectorType> &euler_vector,
- const ComponentMask & mask)
+ const ComponentMask &mask)
: reference_cell(euler_dof_handler.get_fe().reference_cell())
, uses_level_dofs(true)
, euler_dof_handler(&euler_dof_handler)
template <int dim, int spacedim, typename VectorType>
void
MappingFEField<dim, spacedim, VectorType>::compute_shapes_virtual(
- const std::vector<Point<dim>> & unit_points,
+ const std::vector<Point<dim>> &unit_points,
typename MappingFEField<dim, spacedim, VectorType>::InternalData &data) const
{
const auto fe = &euler_dof_handler->get_fe();
const UpdateFlags update_flags,
const Quadrature<dim> &q,
const unsigned int n_original_q_points,
- InternalData & data) const
+ InternalData &data) const
{
// store the flags in the internal data object so we can access them
// in fill_fe_*_values(). use the transitive hull of the required
const UpdateFlags update_flags,
const Quadrature<dim> &q,
const unsigned int n_original_q_points,
- InternalData & data) const
+ InternalData &data) const
{
compute_data(update_flags, q, n_original_q_points, data);
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
std::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
- auto & data = dynamic_cast<InternalData &>(*data_ptr);
+ auto &data = dynamic_cast<InternalData &>(*data_ptr);
const Quadrature<dim> q(
QProjector<dim>::project_to_all_faces(reference_cell, quadrature[0]));
this->compute_face_data(update_flags, q, quadrature[0].size(), data);
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
std::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
- auto & data = dynamic_cast<InternalData &>(*data_ptr);
+ auto &data = dynamic_cast<InternalData &>(*data_ptr);
const Quadrature<dim> q(
QProjector<dim>::project_to_all_subfaces(reference_cell, quadrature));
this->compute_face_data(update_flags, q, quadrature.size(), data);
maybe_compute_q_points(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingFEField<dim, spacedim, VectorType>::
- InternalData & data,
+ InternalData &data,
const FiniteElement<dim, spacedim> &fe,
- const ComponentMask & fe_mask,
- const std::vector<unsigned int> & fe_to_real,
- std::vector<Point<spacedim>> & quadrature_points)
+ const ComponentMask &fe_mask,
+ const std::vector<unsigned int> &fe_to_real,
+ std::vector<Point<spacedim>> &quadrature_points)
{
const UpdateFlags update_flags = data.update_each;
++point)
{
Point<spacedim> result;
- const double * shape = &data.shape(point + data_set, 0);
+ const double *shape = &data.shape(point + data_set, 0);
for (unsigned int k = 0; k < data.n_shape_functions; ++k)
{
maybe_update_Jacobians(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingFEField<dim, spacedim, VectorType>::
- InternalData & data,
+ InternalData &data,
const FiniteElement<dim, spacedim> &fe,
- const ComponentMask & fe_mask,
- const std::vector<unsigned int> & fe_to_real)
+ const ComponentMask &fe_mask,
+ const std::vector<unsigned int> &fe_to_real)
{
const UpdateFlags update_flags = data.update_each;
maybe_update_jacobian_grads(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingFEField<dim, spacedim, VectorType>::
- InternalData & data,
- const FiniteElement<dim, spacedim> & fe,
- const ComponentMask & fe_mask,
- const std::vector<unsigned int> & fe_to_real,
+ InternalData &data,
+ const FiniteElement<dim, spacedim> &fe,
+ const ComponentMask &fe_mask,
+ const std::vector<unsigned int> &fe_to_real,
std::vector<DerivativeForm<2, dim, spacedim>> &jacobian_grads)
{
const UpdateFlags update_flags = data.update_each;
maybe_update_jacobian_pushed_forward_grads(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingFEField<dim, spacedim, VectorType>::
- InternalData & data,
+ InternalData &data,
const FiniteElement<dim, spacedim> &fe,
- const ComponentMask & fe_mask,
- const std::vector<unsigned int> & fe_to_real,
- std::vector<Tensor<3, spacedim>> & jacobian_pushed_forward_grads)
+ const ComponentMask &fe_mask,
+ const std::vector<unsigned int> &fe_to_real,
+ std::vector<Tensor<3, spacedim>> &jacobian_pushed_forward_grads)
{
const UpdateFlags update_flags = data.update_each;
if (update_flags & update_jacobian_pushed_forward_grads)
maybe_update_jacobian_2nd_derivatives(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingFEField<dim, spacedim, VectorType>::
- InternalData & data,
- const FiniteElement<dim, spacedim> & fe,
- const ComponentMask & fe_mask,
- const std::vector<unsigned int> & fe_to_real,
+ InternalData &data,
+ const FiniteElement<dim, spacedim> &fe,
+ const ComponentMask &fe_mask,
+ const std::vector<unsigned int> &fe_to_real,
std::vector<DerivativeForm<3, dim, spacedim>> &jacobian_2nd_derivatives)
{
const UpdateFlags update_flags = data.update_each;
maybe_update_jacobian_pushed_forward_2nd_derivatives(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingFEField<dim, spacedim, VectorType>::
- InternalData & data,
+ InternalData &data,
const FiniteElement<dim, spacedim> &fe,
- const ComponentMask & fe_mask,
- const std::vector<unsigned int> & fe_to_real,
+ const ComponentMask &fe_mask,
+ const std::vector<unsigned int> &fe_to_real,
std::vector<Tensor<4, spacedim>>
&jacobian_pushed_forward_2nd_derivatives)
{
maybe_update_jacobian_3rd_derivatives(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingFEField<dim, spacedim, VectorType>::
- InternalData & data,
- const FiniteElement<dim, spacedim> & fe,
- const ComponentMask & fe_mask,
- const std::vector<unsigned int> & fe_to_real,
+ InternalData &data,
+ const FiniteElement<dim, spacedim> &fe,
+ const ComponentMask &fe_mask,
+ const std::vector<unsigned int> &fe_to_real,
std::vector<DerivativeForm<4, dim, spacedim>> &jacobian_3rd_derivatives)
{
const UpdateFlags update_flags = data.update_each;
maybe_update_jacobian_pushed_forward_3rd_derivatives(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingFEField<dim, spacedim, VectorType>::
- InternalData & data,
+ InternalData &data,
const FiniteElement<dim, spacedim> &fe,
- const ComponentMask & fe_mask,
- const std::vector<unsigned int> & fe_to_real,
+ const ComponentMask &fe_mask,
+ const std::vector<unsigned int> &fe_to_real,
std::vector<Tensor<5, spacedim>>
&jacobian_pushed_forward_3rd_derivatives)
{
maybe_compute_face_data(
const dealii::Mapping<dim, spacedim> &mapping,
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & cell,
+ &cell,
const unsigned int face_no,
const unsigned int subface_no,
const typename QProjector<dim>::DataSetDescriptor data_set,
do_fill_fe_face_values(
const dealii::Mapping<dim, spacedim> &mapping,
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & cell,
+ &cell,
const unsigned int face_no,
const unsigned int subface_no,
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingFEField<dim, spacedim, VectorType>::
- InternalData & data,
+ InternalData &data,
const FiniteElement<dim, spacedim> &fe,
- const ComponentMask & fe_mask,
- const std::vector<unsigned int> & fe_to_real,
+ const ComponentMask &fe_mask,
+ const std::vector<unsigned int> &fe_to_real,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data)
{
MappingFEField<dim, spacedim, VectorType>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
MappingFEField<dim, spacedim, VectorType>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
void
MappingFEField<dim, spacedim, VectorType>::fill_fe_immersed_surface_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const NonMatching::ImmersedSurfaceQuadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const NonMatching::ImmersedSurfaceQuadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
template <int dim, int spacedim, int rank, typename VectorType>
void
transform_fields(
- const ArrayView<const Tensor<rank, dim>> & input,
+ const ArrayView<const Tensor<rank, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<rank, spacedim>> & output)
+ const ArrayView<Tensor<rank, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert((dynamic_cast<
const ArrayView<const DerivativeForm<rank, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<rank + 1, spacedim>> & output)
+ const ArrayView<Tensor<rank + 1, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert((dynamic_cast<
template <int dim, int spacedim, typename VectorType>
void
MappingFEField<dim, spacedim, VectorType>::transform(
- const ArrayView<const Tensor<1, dim>> & input,
+ const ArrayView<const Tensor<1, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<1, spacedim>> & output) const
+ const ArrayView<Tensor<1, spacedim>> &output) const
{
AssertDimension(input.size(), output.size());
const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<2, spacedim>> & output) const
+ const ArrayView<Tensor<2, spacedim>> &output) const
{
AssertDimension(input.size(), output.size());
const ArrayView<const Tensor<2, dim>> &input,
const MappingKind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<2, spacedim>> & output) const
+ const ArrayView<Tensor<2, spacedim>> &output) const
{
(void)input;
(void)output;
const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output) const
+ const ArrayView<Tensor<3, spacedim>> &output) const
{
AssertDimension(input.size(), output.size());
Assert(dynamic_cast<const InternalData *>(&mapping_data) != nullptr,
const ArrayView<const Tensor<3, dim>> &input,
const MappingKind /*mapping_kind*/,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output) const
+ const ArrayView<Tensor<3, spacedim>> &output) const
{
(void)input;
(void)output;
Point<spacedim>
MappingFEField<dim, spacedim, VectorType>::transform_unit_to_real_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
// Use the get_data function to create an InternalData with data vectors of
// the right size and transformation shape values already computed at point
Point<dim>
MappingFEField<dim, spacedim, VectorType>::transform_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<spacedim> & p) const
+ const Point<spacedim> &p) const
{
// first a Newton iteration based on the real mapping. It uses the center
// point of the cell as a starting point
Point<dim>
MappingFEField<dim, spacedim, VectorType>::do_transform_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<spacedim> & p,
- const Point<dim> & initial_p_unit,
- InternalData & mdata) const
+ const Point<spacedim> &p,
+ const Point<dim> &initial_p_unit,
+ InternalData &mdata) const
{
const unsigned int n_shapes = mdata.shape_values.size();
(void)n_shapes;
template <int dim, int spacedim, typename VectorType>
void
MappingFEField<dim, spacedim, VectorType>::update_internal_dofs(
- const typename Triangulation<dim, spacedim>::cell_iterator & cell,
+ const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const typename MappingFEField<dim, spacedim, VectorType>::InternalData &data)
const
{
Point<spacedim>
MappingManifold<dim, spacedim>::transform_unit_to_real_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell> vertices;
std::array<double, GeometryInfo<dim>::vertices_per_cell> weights;
maybe_compute_q_points(
const typename QProjector<dim>::DataSetDescriptor data_set,
const typename dealii::MappingManifold<dim, spacedim>::InternalData
- & data,
+ &data,
std::vector<Point<spacedim>> &quadrature_points)
{
const UpdateFlags update_flags = data.update_each;
MappingManifold<dim, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
maybe_compute_face_data(
const dealii::MappingManifold<dim, spacedim> &mapping,
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & cell,
+ &cell,
const unsigned int face_no,
const unsigned int subface_no,
const unsigned int n_q_points,
do_fill_fe_face_values(
const dealii::MappingManifold<dim, spacedim> &mapping,
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- & cell,
+ &cell,
const unsigned int face_no,
const unsigned int subface_no,
const typename QProjector<dim>::DataSetDescriptor data_set,
- const Quadrature<dim - 1> & quadrature,
+ const Quadrature<dim - 1> &quadrature,
const typename dealii::MappingManifold<dim, spacedim>::InternalData
&data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
template <int dim, int spacedim, int rank>
void
transform_fields(
- const ArrayView<const Tensor<rank, dim>> & input,
+ const ArrayView<const Tensor<rank, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<rank, spacedim>> & output)
+ const ArrayView<Tensor<rank, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert((dynamic_cast<const typename dealii::
template <int dim, int spacedim, int rank>
void
transform_gradients(
- const ArrayView<const Tensor<rank, dim>> & input,
+ const ArrayView<const Tensor<rank, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<rank, spacedim>> & output)
+ const ArrayView<Tensor<rank, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert((dynamic_cast<const typename dealii::
template <int dim, int spacedim>
void
transform_hessians(
- const ArrayView<const Tensor<3, dim>> & input,
+ const ArrayView<const Tensor<3, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output)
+ const ArrayView<Tensor<3, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert((dynamic_cast<const typename dealii::
const ArrayView<const DerivativeForm<rank, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<rank + 1, spacedim>> & output)
+ const ArrayView<Tensor<rank + 1, spacedim>> &output)
{
AssertDimension(input.size(), output.size());
Assert((dynamic_cast<const typename dealii::
MappingManifold<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
template <int dim, int spacedim>
void
MappingManifold<dim, spacedim>::transform(
- const ArrayView<const Tensor<1, dim>> & input,
+ const ArrayView<const Tensor<1, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<1, spacedim>> & output) const
+ const ArrayView<Tensor<1, spacedim>> &output) const
{
internal::MappingManifoldImplementation::transform_fields(input,
mapping_kind,
const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<2, spacedim>> & output) const
+ const ArrayView<Tensor<2, spacedim>> &output) const
{
internal::MappingManifoldImplementation::transform_differential_forms(
input, mapping_kind, mapping_data, output);
template <int dim, int spacedim>
void
MappingManifold<dim, spacedim>::transform(
- const ArrayView<const Tensor<2, dim>> & input,
+ const ArrayView<const Tensor<2, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<2, spacedim>> & output) const
+ const ArrayView<Tensor<2, spacedim>> &output) const
{
switch (mapping_kind)
{
const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output) const
+ const ArrayView<Tensor<3, spacedim>> &output) const
{
AssertDimension(input.size(), output.size());
Assert(dynamic_cast<const InternalData *>(&mapping_data) != nullptr,
template <int dim, int spacedim>
void
MappingManifold<dim, spacedim>::transform(
- const ArrayView<const Tensor<3, dim>> & input,
+ const ArrayView<const Tensor<3, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output) const
+ const ArrayView<Tensor<3, spacedim>> &output) const
{
switch (mapping_kind)
{
Point<spacedim>
MappingQ<dim, spacedim>::transform_unit_to_real_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<dim> & p) const
+ const Point<dim> &p) const
{
return Point<spacedim>(internal::evaluate_tensor_product_value(
polynomials_1d,
Point<1>
MappingQ<1, 1>::transform_real_to_unit_cell_internal(
const Triangulation<1, 1>::cell_iterator &cell,
- const Point<1> & p,
- const Point<1> & initial_p_unit) const
+ const Point<1> &p,
+ const Point<1> &initial_p_unit) const
{
// dispatch to the various specializations for spacedim=dim,
// spacedim=dim+1, etc
Point<2>
MappingQ<2, 2>::transform_real_to_unit_cell_internal(
const Triangulation<2, 2>::cell_iterator &cell,
- const Point<2> & p,
- const Point<2> & initial_p_unit) const
+ const Point<2> &p,
+ const Point<2> &initial_p_unit) const
{
return internal::MappingQImplementation::
do_transform_real_to_unit_cell_internal<2>(
Point<3>
MappingQ<3, 3>::transform_real_to_unit_cell_internal(
const Triangulation<3, 3>::cell_iterator &cell,
- const Point<3> & p,
- const Point<3> & initial_p_unit) const
+ const Point<3> &p,
+ const Point<3> &initial_p_unit) const
{
return internal::MappingQImplementation::
do_transform_real_to_unit_cell_internal<3>(
Point<1>
MappingQ<1, 2>::transform_real_to_unit_cell_internal(
const Triangulation<1, 2>::cell_iterator &cell,
- const Point<2> & p,
- const Point<1> & initial_p_unit) const
+ const Point<2> &p,
+ const Point<1> &initial_p_unit) const
{
const int dim = 1;
const int spacedim = 2;
Point<2>
MappingQ<2, 3>::transform_real_to_unit_cell_internal(
const Triangulation<2, 3>::cell_iterator &cell,
- const Point<3> & p,
- const Point<2> & initial_p_unit) const
+ const Point<3> &p,
+ const Point<2> &initial_p_unit) const
{
const int dim = 2;
const int spacedim = 3;
Point<dim>
MappingQ<dim, spacedim>::transform_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<spacedim> & p) const
+ const Point<spacedim> &p) const
{
// Use an exact formula if one is available. this is only the case
// for Q1 mappings in 1d, and in 2d if dim==spacedim
void
MappingQ<dim, spacedim>::transform_points_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const ArrayView<const Point<spacedim>> & real_points,
- const ArrayView<Point<dim>> & unit_points) const
+ const ArrayView<const Point<spacedim>> &real_points,
+ const ArrayView<Point<dim>> &unit_points) const
{
// Go to base class functions for dim < spacedim because it is not yet
// implemented with optimized code.
MappingQ<dim, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity cell_similarity,
- const Quadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
MappingQ<dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const hp::QCollection<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const hp::QCollection<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const Quadrature<dim - 1> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
void
MappingQ<dim, spacedim>::fill_fe_immersed_surface_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const NonMatching::ImmersedSurfaceQuadrature<dim> & quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const NonMatching::ImmersedSurfaceQuadrature<dim> &quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
void
MappingQ<dim, spacedim>::fill_mapping_data_for_generic_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const ArrayView<const Point<dim>> & unit_points,
+ const ArrayView<const Point<dim>> &unit_points,
const UpdateFlags update_flags,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
MappingQ<dim, spacedim>::fill_mapping_data_for_face_quadrature(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
- const Quadrature<dim - 1> & face_quadrature,
- const typename Mapping<dim, spacedim>::InternalDataBase & internal_data,
+ const Quadrature<dim - 1> &face_quadrature,
+ const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
{
template <int dim, int spacedim>
void
MappingQ<dim, spacedim>::transform(
- const ArrayView<const Tensor<1, dim>> & input,
+ const ArrayView<const Tensor<1, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<1, spacedim>> & output) const
+ const ArrayView<Tensor<1, spacedim>> &output) const
{
internal::MappingQImplementation::transform_fields(input,
mapping_kind,
const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<2, spacedim>> & output) const
+ const ArrayView<Tensor<2, spacedim>> &output) const
{
internal::MappingQImplementation::transform_differential_forms(input,
mapping_kind,
template <int dim, int spacedim>
void
MappingQ<dim, spacedim>::transform(
- const ArrayView<const Tensor<2, dim>> & input,
+ const ArrayView<const Tensor<2, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<2, spacedim>> & output) const
+ const ArrayView<Tensor<2, spacedim>> &output) const
{
switch (mapping_kind)
{
const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output) const
+ const ArrayView<Tensor<3, spacedim>> &output) const
{
AssertDimension(input.size(), output.size());
Assert(dynamic_cast<const InternalData *>(&mapping_data) != nullptr,
template <int dim, int spacedim>
void
MappingQ<dim, spacedim>::transform(
- const ArrayView<const Tensor<3, dim>> & input,
+ const ArrayView<const Tensor<3, dim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
- const ArrayView<Tensor<3, spacedim>> & output) const
+ const ArrayView<Tensor<3, spacedim>> &output) const
{
switch (mapping_kind)
{
void
MappingQ<dim, spacedim>::add_line_support_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- std::vector<Point<spacedim>> & a) const
+ std::vector<Point<spacedim>> &a) const
{
// if we only need the midpoint, then ask for it.
if (this->polynomial_degree == 2)
void
MappingQ<3, 3>::add_quad_support_points(
const Triangulation<3, 3>::cell_iterator &cell,
- std::vector<Point<3>> & a) const
+ std::vector<Point<3>> &a) const
{
const unsigned int faces_per_cell = GeometryInfo<3>::faces_per_cell;
void
MappingQ<2, 3>::add_quad_support_points(
const Triangulation<2, 3>::cell_iterator &cell,
- std::vector<Point<3>> & a) const
+ std::vector<Point<3>> &a) const
{
std::array<Point<3>, GeometryInfo<2>::vertices_per_cell> vertices;
for (const unsigned int i : GeometryInfo<2>::vertex_indices())
template <int dim, typename VectorType, int spacedim>
MappingQ1Eulerian<dim, VectorType, spacedim>::MappingQ1Eulerian(
const DoFHandler<dim, spacedim> &shiftmap_dof_handler,
- const VectorType & euler_transform_vectors)
+ const VectorType &euler_transform_vectors)
: MappingQ<dim, spacedim>(1)
, euler_transform_vectors(&euler_transform_vectors)
, shiftmap_dof_handler(&shiftmap_dof_handler)
MappingQ1Eulerian<dim, VectorType, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
template <int dim, int spacedim>
void
MappingQCache<dim, spacedim>::initialize(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &triangulation)
{
// FE and FEValues in the case they are needed
template <int dim, int spacedim>
void
MappingQCache<dim, spacedim>::initialize(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &tria,
const std::function<Point<spacedim>(
const typename Triangulation<dim, spacedim>::cell_iterator &,
- const Point<spacedim> &)> & transformation_function,
+ const Point<spacedim> &)> &transformation_function,
const bool function_describes_relative_displacement)
{
// FE and FEValues in the case they are needed
template <int dim, int spacedim>
void
MappingQCache<dim, spacedim>::initialize(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &tria,
- const Function<spacedim> & transformation_function,
+ const Function<spacedim> &transformation_function,
const bool function_describes_relative_displacement)
{
AssertDimension(transformation_function.n_components, spacedim);
template <typename VectorType>
void
MappingQCache<dim, spacedim>::initialize(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const VectorType & vector,
+ const VectorType &vector,
const bool vector_describes_relative_displacement)
{
AssertDimension(dof_handler.get_fe_collection().size(), 1);
template <typename VectorType>
void
MappingQCache<dim, spacedim>::initialize(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
const MGLevelObject<VectorType> &vectors,
const bool vector_describes_relative_displacement)
#if deal_II_dimension <= deal_II_space_dimension
template void
MappingQCache<deal_II_dimension, deal_II_space_dimension>::initialize(
- const Mapping<deal_II_dimension, deal_II_space_dimension> & mapping,
+ const Mapping<deal_II_dimension, deal_II_space_dimension> &mapping,
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof_handler,
- const deal_II_vec & vector,
+ const deal_II_vec &vector,
const bool vector_describes_relative_displacement);
template void
MappingQCache<deal_II_dimension, deal_II_space_dimension>::initialize(
- const Mapping<deal_II_dimension, deal_II_space_dimension> & mapping,
+ const Mapping<deal_II_dimension, deal_II_space_dimension> &mapping,
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof_handler,
- const MGLevelObject<deal_II_vec> & vector,
+ const MGLevelObject<deal_II_vec> &vector,
const bool vector_describes_relative_displacement);
#endif
}
MappingQEulerian<dim, VectorType, spacedim>::MappingQEulerian(
const unsigned int degree,
const DoFHandler<dim, spacedim> &euler_dof_handler,
- const VectorType & euler_vector,
+ const VectorType &euler_vector,
const unsigned int level)
: MappingQ<dim, spacedim>(degree)
, euler_vector(&euler_vector)
MappingQEulerian<dim, VectorType, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const typename Mapping<dim, spacedim>::InternalDataBase &internal_data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data) const
# ifdef DEAL_II_WITH_OPENCASCADE
template <int spacedim>
void
- create_triangulation_from_boundary_curve(const TopoDS_Edge & boundary,
+ create_triangulation_from_boundary_curve(const TopoDS_Edge &boundary,
Triangulation<2, spacedim> &tria,
const AdditionalParameters &prm)
{
#if deal_II_dimension > 1
template void create_triangulation_from_boundary_curve(
- const TopoDS_Edge & boundary,
+ const TopoDS_Edge &boundary,
Triangulation<2, deal_II_dimension> &tria,
- const AdditionalParameters & prm);
+ const AdditionalParameters &prm);
#endif
}
CellId::CellId(const types::coarse_cell_id coarse_cell_id,
const unsigned int n_child_indices,
- const std::uint8_t * id)
+ const std::uint8_t *id)
: coarse_cell_id(coarse_cell_id)
, n_child_indices(n_child_indices)
{
*/
void
create_triangulation(
- Triangulation<2> & tria_grid,
+ Triangulation<2> &tria_grid,
std::vector<GridTools::PeriodicFacePair<
typename Triangulation<2>::cell_iterator>> *periodic_faces) const
{
* airfoil points.
*/
static std::array<std::vector<Point<2>>, 2>
- joukowski(const Point<2> & centerpoint,
+ joukowski(const Point<2> ¢erpoint,
const unsigned int number_points,
const unsigned int factor)
{
* point with most negative x-component, then counterclockwise.
*/
static std::vector<Point<2>>
- joukowski_circle(const Point<2> & center,
+ joukowski_circle(const Point<2> ¢er,
const unsigned int number_points)
{
std::vector<Point<2>> circle_points;
std::vector<Triangulation<2>> trias(10);
// helper function to create a subdivided quadrilateral
- auto make = [](Triangulation<2> & tria,
- const std::vector<Point<2>> & corner_vertices,
+ auto make = [](Triangulation<2> &tria,
+ const std::vector<Point<2>> &corner_vertices,
const std::vector<unsigned int> &repetitions,
const unsigned int material_id) {
// create subdivided rectangle with corner points (-1,-1)
// move all vertices to the correct position
for (auto it = tria.begin_vertex(); it < tria.end_vertex(); ++it)
{
- auto & point = it->vertex();
+ auto &point = it->vertex();
const double xi = point(0);
const double eta = point(1);
void
internal_create_triangulation(
- Triangulation<2, 2> & tria,
+ Triangulation<2, 2> &tria,
std::vector<GridTools::PeriodicFacePair<
typename Triangulation<2, 2>::cell_iterator>> *periodic_faces,
- const AdditionalData & additional_data)
+ const AdditionalData &additional_data)
{
MeshGenerator mesh_generator(additional_data);
// Cast the triangulation to the right type so that the right
template <>
void
- create_triangulation(Triangulation<2, 2> & tria,
+ create_triangulation(Triangulation<2, 2> &tria,
const AdditionalData &additional_data)
{
internal_create_triangulation(tria, nullptr, additional_data);
template <>
void
create_triangulation(
- Triangulation<2, 2> & tria,
+ Triangulation<2, 2> &tria,
std::vector<GridTools::PeriodicFacePair<
typename Triangulation<2, 2>::cell_iterator>> &periodic_faces,
- const AdditionalData & additional_data)
+ const AdditionalData &additional_data)
{
internal_create_triangulation(tria, &periodic_faces, additional_data);
}
template <>
void
create_triangulation(
- Triangulation<3, 3> & tria,
+ Triangulation<3, 3> &tria,
std::vector<GridTools::PeriodicFacePair<
typename Triangulation<3, 3>::cell_iterator>> &periodic_faces,
- const AdditionalData & additional_data)
+ const AdditionalData &additional_data)
{
Assert(false, ExcMessage("3d airfoils are not implemented yet!"));
(void)tria;
template <int dim, int spacedim>
void
colorize_subdivided_hyper_rectangle(Triangulation<dim, spacedim> &tria,
- const Point<spacedim> & p1,
- const Point<spacedim> & p2,
+ const Point<spacedim> &p1,
+ const Point<spacedim> &p2,
const double epsilon)
{
// run through all faces and check
*/
void
colorize_quarter_hyper_shell(Triangulation<3> &tria,
- const Point<3> & center,
+ const Point<3> ¢er,
const double inner_radius,
const double outer_radius)
{
template <int dim, int spacedim>
void
hyper_rectangle(Triangulation<dim, spacedim> &tria,
- const Point<dim> & p_1,
- const Point<dim> & p_2,
+ const Point<dim> &p_1,
+ const Point<dim> &p_2,
const bool colorize)
{
// First, extend dimensions from dim to spacedim and
template <int dim, int spacedim>
void
reference_cell(Triangulation<dim, spacedim> &tria,
- const ReferenceCell & reference_cell)
+ const ReferenceCell &reference_cell)
{
AssertDimension(dim, reference_cell.get_dimension());
}
void
- moebius(Triangulation<3> & tria,
+ moebius(Triangulation<3> &tria,
const unsigned int n_cells,
const unsigned int n_rotations,
const double R,
template <int dim, int spacedim>
void
- general_cell(Triangulation<dim, spacedim> & tria,
+ general_cell(Triangulation<dim, spacedim> &tria,
const std::vector<Point<spacedim>> &vertices,
const bool colorize)
{
template <>
void
parallelogram(Triangulation<3> &,
- const Point<3> (&/*corners*/)[3],
+ const Point<3> (& /*corners*/)[3],
const bool /*colorize*/)
{
Assert(false, ExcNotImplemented());
template <>
void
parallelogram(Triangulation<1> &,
- const Point<1> (&/*corners*/)[1],
+ const Point<1> (& /*corners*/)[1],
const bool /*colorize*/)
{
Assert(false, ExcNotImplemented());
// similar to parallelogram().
template <int dim, int spacedim>
void
- subdivided_parallelepiped(Triangulation<dim, spacedim> & tria,
- const Point<spacedim> & origin,
+ subdivided_parallelepiped(Triangulation<dim, spacedim> &tria,
+ const Point<spacedim> &origin,
const std::array<Tensor<1, spacedim>, dim> &edges,
const std::vector<unsigned int> &subdivisions,
const bool colorize)
template <int dim, int spacedim>
void
- subdivided_hyper_rectangle(Triangulation<dim, spacedim> & tria,
+ subdivided_hyper_rectangle(Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &repetitions,
- const Point<dim> & p_1,
- const Point<dim> & p_2,
+ const Point<dim> &p_1,
+ const Point<dim> &p_2,
const bool colorize)
{
Assert(repetitions.size() == dim, ExcInvalidRepetitionsDimension(dim));
template <int dim>
void
- subdivided_hyper_rectangle(Triangulation<dim> & tria,
+ subdivided_hyper_rectangle(Triangulation<dim> &tria,
const std::vector<std::vector<double>> &step_sz,
- const Point<dim> & p_1,
- const Point<dim> & p_2,
+ const Point<dim> &p_1,
+ const Point<dim> &p_2,
const bool colorize)
{
Assert(step_sz.size() == dim, ExcInvalidRepetitionsDimension(dim));
template <>
void
- subdivided_hyper_rectangle(Triangulation<1> & tria,
+ subdivided_hyper_rectangle(Triangulation<1> &tria,
const std::vector<std::vector<double>> &spacing,
- const Point<1> & p,
+ const Point<1> &p,
const Table<1, types::material_id> &material_id,
const bool colorize)
{
template <>
void
- subdivided_hyper_rectangle(Triangulation<2> & tria,
+ subdivided_hyper_rectangle(Triangulation<2> &tria,
const std::vector<std::vector<double>> &spacing,
- const Point<2> & p,
+ const Point<2> &p,
const Table<2, types::material_id> &material_id,
const bool colorize)
{
template <>
void
- subdivided_hyper_rectangle(Triangulation<3> & tria,
+ subdivided_hyper_rectangle(Triangulation<3> &tria,
const std::vector<std::vector<double>> &spacing,
- const Point<3> & p,
+ const Point<3> &p,
const Table<3, types::material_id> &material_id,
const bool colorize)
{
template <int dim, int spacedim>
void
- cheese(Triangulation<dim, spacedim> & tria,
+ cheese(Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &holes)
{
AssertDimension(holes.size(), dim);
template <>
void
- plate_with_a_hole(Triangulation<2> & tria,
+ plate_with_a_hole(Triangulation<2> &tria,
const double inner_radius,
const double outer_radius,
const double pad_bottom,
const double pad_top,
const double pad_left,
const double pad_right,
- const Point<2> & new_center,
+ const Point<2> &new_center,
const types::manifold_id polar_manifold_id,
const types::manifold_id tfi_manifold_id,
const double L,
template <>
void
- plate_with_a_hole(Triangulation<3> & tria,
+ plate_with_a_hole(Triangulation<3> &tria,
const double inner_radius,
const double outer_radius,
const double pad_bottom,
const double pad_top,
const double pad_left,
const double pad_right,
- const Point<3> & new_center,
+ const Point<3> &new_center,
const types::manifold_id polar_manifold_id,
const types::manifold_id tfi_manifold_id,
const double L,
template <>
void
- channel_with_cylinder(Triangulation<2> & tria,
+ channel_with_cylinder(Triangulation<2> &tria,
const double shell_region_width,
const unsigned int n_shells,
const double skewness,
template <>
void
- channel_with_cylinder(Triangulation<3> & tria,
+ channel_with_cylinder(Triangulation<3> &tria,
const double shell_region_width,
const unsigned int n_shells,
const double skewness,
template <int dim, int spacedim>
void
- hyper_cross(Triangulation<dim, spacedim> & tria,
+ hyper_cross(Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &sizes,
const bool colorize)
{
{
const double rl2 = (right + left) / 2;
const Point<2> vertices[10] = {Point<2>(left, left),
- Point<2>(rl2, left),
- Point<2>(rl2, rl2),
- Point<2>(left, rl2),
- Point<2>(right, left),
- Point<2>(right, rl2),
- Point<2>(rl2, right),
- Point<2>(left, right),
- Point<2>(right, right),
- Point<2>(rl2, left)};
+ Point<2>(rl2, left),
+ Point<2>(rl2, rl2),
+ Point<2>(left, rl2),
+ Point<2>(right, left),
+ Point<2>(right, rl2),
+ Point<2>(rl2, right),
+ Point<2>(left, right),
+ Point<2>(right, right),
+ Point<2>(rl2, left)};
const int cell_vertices[4][4] = {{0, 1, 3, 2},
- {9, 4, 2, 5},
- {3, 2, 7, 6},
- {2, 5, 6, 8}};
+ {9, 4, 2, 5},
+ {3, 2, 7, 6},
+ {2, 5, 6, 8}};
std::vector<CellData<2>> cells(4, CellData<2>());
for (unsigned int i = 0; i < 4; ++i)
{
const bool colorize)
{
const Point<2> vertices[8] = {Point<2>(a, a),
- Point<2>((a + b) / 2, a),
- Point<2>(b, a),
- Point<2>(a, (a + b) / 2),
- Point<2>((a + b) / 2, (a + b) / 2),
- Point<2>(b, (a + b) / 2),
- Point<2>(a, b),
- Point<2>((a + b) / 2, b)};
+ Point<2>((a + b) / 2, a),
+ Point<2>(b, a),
+ Point<2>(a, (a + b) / 2),
+ Point<2>((a + b) / 2, (a + b) / 2),
+ Point<2>(b, (a + b) / 2),
+ Point<2>(a, b),
+ Point<2>((a + b) / 2, b)};
const int cell_vertices[3][4] = {{0, 1, 3, 4}, {1, 2, 4, 5}, {3, 4, 6, 7}};
std::vector<CellData<2>> cells(3, CellData<2>());
template <int dim, int spacedim>
void
- subdivided_hyper_L(Triangulation<dim, spacedim> & tria,
+ subdivided_hyper_L(Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &repetitions,
- const Point<dim> & bottom_left,
- const Point<dim> & top_right,
- const std::vector<int> & n_cells_to_remove)
+ const Point<dim> &bottom_left,
+ const Point<dim> &top_right,
+ const std::vector<int> &n_cells_to_remove)
{
Assert(dim > 1, ExcNotImplemented());
// Check the consistency of the dimensions provided.
template <>
void
hyper_ball(Triangulation<2> &tria,
- const Point<2> & p,
+ const Point<2> &p,
const double radius,
const bool internal_manifolds)
{
template <>
void
- hyper_shell(Triangulation<2> & tria,
- const Point<2> & center,
+ hyper_shell(Triangulation<2> &tria,
+ const Point<2> ¢er,
const double inner_radius,
const double outer_radius,
const unsigned int n_cells,
template <int dim>
void
eccentric_hyper_shell(Triangulation<dim> &tria,
- const Point<dim> & inner_center,
- const Point<dim> & outer_center,
+ const Point<dim> &inner_center,
+ const Point<dim> &outer_center,
const double inner_radius,
const double outer_radius,
const unsigned int n_cells)
template <>
void
quarter_hyper_ball(Triangulation<2> &tria,
- const Point<2> & p,
+ const Point<2> &p,
const double radius)
{
const unsigned int dim = 2;
template <>
void
half_hyper_ball(Triangulation<2> &tria,
- const Point<2> & p,
+ const Point<2> &p,
const double radius)
{
// equilibrate cell sizes at
// Implementation for 2d only
template <>
void
- half_hyper_shell(Triangulation<2> & tria,
- const Point<2> & center,
+ half_hyper_shell(Triangulation<2> &tria,
+ const Point<2> ¢er,
const double inner_radius,
const double outer_radius,
const unsigned int n_cells,
template <>
void
- quarter_hyper_shell(Triangulation<2> & tria,
- const Point<2> & center,
+ quarter_hyper_shell(Triangulation<2> &tria,
+ const Point<2> ¢er,
const double inner_radius,
const double outer_radius,
const unsigned int n_cells,
template <>
void
hyper_ball(Triangulation<3> &tria,
- const Point<3> & p,
+ const Point<3> &p,
const double radius,
const bool internal_manifold)
{
void
- non_standard_orientation_mesh(Triangulation<2> & tria,
+ non_standard_orientation_mesh(Triangulation<2> &tria,
const unsigned int n_rotate_middle_square)
{
AssertThrow(n_rotate_middle_square < 4,
template <int spacedim>
void
hyper_sphere(Triangulation<spacedim - 1, spacedim> &tria,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const double radius)
{
Triangulation<spacedim> volume_mesh;
// Implementation for 3d only
template <>
void
- subdivided_cylinder(Triangulation<3> & tria,
+ subdivided_cylinder(Triangulation<3> &tria,
const unsigned int x_subdivisions,
const double radius,
const double half_length)
template <>
void
quarter_hyper_ball(Triangulation<3> &tria,
- const Point<3> & center,
+ const Point<3> ¢er,
const double radius)
{
const unsigned int dim = 3;
template <>
void
half_hyper_ball(Triangulation<3> &tria,
- const Point<3> & center,
+ const Point<3> ¢er,
const double radius)
{
// These are for the two lower squares
template <int dim>
void
hyper_ball_balanced(Triangulation<dim> &tria,
- const Point<dim> & p,
+ const Point<dim> &p,
const double radius)
{
// We create the ball by duplicating the information in each dimension at
{
void
hyper_shell_6(Triangulation<3> &tria,
- const Point<3> & p,
+ const Point<3> &p,
const double inner_radius,
const double outer_radius)
{
void
hyper_shell_12(Triangulation<3> &tria,
- const Point<3> & p,
+ const Point<3> &p,
const double inner_radius,
const double outer_radius)
{
}
void
- hyper_shell_24_48(Triangulation<3> & tria,
+ hyper_shell_24_48(Triangulation<3> &tria,
const unsigned int n,
const unsigned int n_refinement_steps,
- const Point<3> & p,
+ const Point<3> &p,
const double inner_radius,
const double outer_radius)
{
template <>
void
- hyper_shell(Triangulation<3> & tria,
- const Point<3> & p,
+ hyper_shell(Triangulation<3> &tria,
+ const Point<3> &p,
const double inner_radius,
const double outer_radius,
const unsigned int n_cells,
template <>
void
half_hyper_shell(Triangulation<3> &tria,
- const Point<3> & center,
+ const Point<3> ¢er,
const double inner_radius,
const double outer_radius,
const unsigned int /*n_cells*/,
// Implementation for 3d only
template <>
void
- quarter_hyper_shell(Triangulation<3> & tria,
- const Point<3> & center,
+ quarter_hyper_shell(Triangulation<3> &tria,
+ const Point<3> ¢er,
const double inner_radius,
const double outer_radius,
const unsigned int n,
// Implementation for 3d only
template <>
void
- cylinder_shell(Triangulation<3> & tria,
+ cylinder_shell(Triangulation<3> &tria,
const double length,
const double inner_radius,
const double outer_radius,
void
merge_triangulations(
const std::vector<const Triangulation<dim, spacedim> *> &triangulations,
- Triangulation<dim, spacedim> & result,
+ Triangulation<dim, spacedim> &result,
const double duplicated_vertex_tolerance,
const bool copy_manifold_ids,
const bool copy_boundary_ids)
void
merge_triangulations(const Triangulation<dim, spacedim> &triangulation_1,
const Triangulation<dim, spacedim> &triangulation_2,
- Triangulation<dim, spacedim> & result,
+ Triangulation<dim, spacedim> &result,
const double duplicated_vertex_tolerance,
const bool copy_manifold_ids,
const bool copy_boundary_ids)
template <int dim, int spacedim>
void
replicate_triangulation(const Triangulation<dim, spacedim> &input,
- const std::vector<unsigned int> & extents,
- Triangulation<dim, spacedim> & result)
+ const std::vector<unsigned int> &extents,
+ Triangulation<dim, spacedim> &result)
{
AssertDimension(dim, extents.size());
# ifdef DEBUG
"each coordinate dimension."));
# endif
const BoundingBox<spacedim> bbox(input.get_vertices());
- const auto & min = bbox.get_boundary_points().first;
- const auto & max = bbox.get_boundary_points().second;
+ const auto &min = bbox.get_boundary_points().first;
+ const auto &max = bbox.get_boundary_points().second;
std::array<Tensor<1, spacedim>, dim> offsets;
for (unsigned int d = 0; d < dim; ++d)
create_union_triangulation(
const Triangulation<dim, spacedim> &triangulation_1,
const Triangulation<dim, spacedim> &triangulation_2,
- Triangulation<dim, spacedim> & result)
+ Triangulation<dim, spacedim> &result)
{
Assert(GridTools::have_same_coarse_mesh(triangulation_1, triangulation_2),
ExcMessage("The two input triangulations are not derived from "
create_triangulation_with_removed_cells(
const Triangulation<dim, spacedim> &input_triangulation,
const std::set<typename Triangulation<dim, spacedim>::active_cell_iterator>
- & cells_to_remove,
+ &cells_to_remove,
Triangulation<dim, spacedim> &result)
{
// simply copy the vertices; we will later strip those
void
extrude_triangulation(
- const Triangulation<2, 2> & input,
+ const Triangulation<2, 2> &input,
const unsigned int n_slices,
const double height,
- Triangulation<3, 3> & result,
+ Triangulation<3, 3> &result,
const bool copy_manifold_ids,
const std::vector<types::manifold_id> &manifold_priorities)
{
void
extrude_triangulation(
- const Triangulation<2, 2> & input,
+ const Triangulation<2, 2> &input,
const unsigned int n_slices,
const double height,
- Triangulation<2, 2> & result,
+ Triangulation<2, 2> &result,
const bool copy_manifold_ids,
const std::vector<types::manifold_id> &manifold_priorities)
{
void
extrude_triangulation(
- const Triangulation<2, 2> & input,
- const std::vector<double> & slice_coordinates,
- Triangulation<3, 3> & result,
+ const Triangulation<2, 2> &input,
+ const std::vector<double> &slice_coordinates,
+ Triangulation<3, 3> &result,
const bool copy_manifold_ids,
const std::vector<types::manifold_id> &manifold_priorities)
{
void
extrude_triangulation(
- const Triangulation<2, 2> & input,
- const std::vector<double> & slice_coordinates,
- Triangulation<2, 2> & result,
+ const Triangulation<2, 2> &input,
+ const std::vector<double> &slice_coordinates,
+ Triangulation<2, 2> &result,
const bool copy_manifold_ids,
const std::vector<types::manifold_id> &manifold_priorities)
{
template <int dim>
void
concentric_hyper_shells(Triangulation<dim> &triangulation,
- const Point<dim> & center,
+ const Point<dim> ¢er,
const double inner_radius,
const double outer_radius,
const unsigned int n_shells,
template <>
void
- hyper_cube_with_cylindrical_hole(Triangulation<3> & triangulation,
+ hyper_cube_with_cylindrical_hole(Triangulation<3> &triangulation,
const double inner_radius,
const double outer_radius,
const double L,
template <int dim, int spacedim1, int spacedim2>
void
flatten_triangulation(const Triangulation<dim, spacedim1> &in_tria,
- Triangulation<dim, spacedim2> & out_tria)
+ Triangulation<dim, spacedim2> &out_tria)
{
Assert((dynamic_cast<
const parallel::distributed::Triangulation<dim, spacedim1> *>(
// above once.)
if ((face->user_flag_set() == false) &&
(face->manifold_id() != numbers::flat_manifold_id))
- {
- CellData<1> boundary_line;
+ {
+ CellData<1> boundary_line;
- boundary_line.vertices.resize(face->n_vertices());
- for (const auto i : face->vertex_indices())
- boundary_line.vertices[i] = face->vertex_index(i);
- boundary_line.boundary_id =
- numbers::internal_face_boundary_id;
- boundary_line.manifold_id = face->manifold_id();
+ boundary_line.vertices.resize(face->n_vertices());
+ for (const auto i : face->vertex_indices())
+ boundary_line.vertices[i] = face->vertex_index(i);
+ boundary_line.boundary_id =
+ numbers::internal_face_boundary_id;
+ boundary_line.manifold_id = face->manifold_id();
- subcelldata.boundary_lines.emplace_back(
- std::move(boundary_line));
+ subcelldata.boundary_lines.emplace_back(
+ std::move(boundary_line));
- face->set_user_flag();
- }
+ face->set_user_flag();
+ }
}
// Reset the user flags to their previous values:
// have also already dealt with the edges and don't have
// to worry about that any more separately.
if (face->user_flag_set() == false)
- {
- if (face->manifold_id() != numbers::flat_manifold_id)
- {
- CellData<2> boundary_face;
-
- boundary_face.vertices.resize(face->n_vertices());
- for (const auto i : face->vertex_indices())
- boundary_face.vertices[i] = face->vertex_index(i);
- boundary_face.boundary_id =
- numbers::internal_face_boundary_id;
- boundary_face.manifold_id = face->manifold_id();
-
- subcelldata.boundary_quads.emplace_back(
- std::move(boundary_face));
+ {
+ if (face->manifold_id() != numbers::flat_manifold_id)
+ {
+ CellData<2> boundary_face;
- face->set_user_flag();
- }
+ boundary_face.vertices.resize(face->n_vertices());
+ for (const auto i : face->vertex_indices())
+ boundary_face.vertices[i] = face->vertex_index(i);
+ boundary_face.boundary_id =
+ numbers::internal_face_boundary_id;
+ boundary_face.manifold_id = face->manifold_id();
- // Then also loop over the edges of this face. Because every
- // boundary edge must also be a part of a boundary face, we
- // can ignore these. But it is possible that we have already
- // encountered an interior edge through a previous face, and
- // in that case we have to just ignore it
- for (unsigned int e = 0; e < face->n_lines(); ++e)
- if (face->line(e)->at_boundary() == false)
- if (face->line(e)->user_flag_set() == false)
- {
- const typename Triangulation<dim, spacedim1>::
- line_iterator edge = face->line(e);
- CellData<1> boundary_edge;
-
- boundary_edge.vertices.resize(edge->n_vertices());
- for (const auto i : edge->vertex_indices())
- boundary_edge.vertices[i] = edge->vertex_index(i);
- boundary_edge.boundary_id =
- numbers::internal_face_boundary_id;
- boundary_edge.manifold_id = edge->manifold_id();
+ subcelldata.boundary_quads.emplace_back(
+ std::move(boundary_face));
- subcelldata.boundary_lines.emplace_back(
- std::move(boundary_edge));
+ face->set_user_flag();
+ }
- edge->set_user_flag();
- }
- }
+ // Then also loop over the edges of this face. Because
+ // every boundary edge must also be a part of a boundary
+ // face, we can ignore these. But it is possible that we
+ // have already encountered an interior edge through a
+ // previous face, and in that case we have to just ignore
+ // it
+ for (unsigned int e = 0; e < face->n_lines(); ++e)
+ if (face->line(e)->at_boundary() == false)
+ if (face->line(e)->user_flag_set() == false)
+ {
+ const typename Triangulation<dim, spacedim1>::
+ line_iterator edge = face->line(e);
+ CellData<1> boundary_edge;
+
+ boundary_edge.vertices.resize(edge->n_vertices());
+ for (const auto i : edge->vertex_indices())
+ boundary_edge.vertices[i] =
+ edge->vertex_index(i);
+ boundary_edge.boundary_id =
+ numbers::internal_face_boundary_id;
+ boundary_edge.manifold_id = edge->manifold_id();
+
+ subcelldata.boundary_lines.emplace_back(
+ std::move(boundary_edge));
+
+ edge->set_user_flag();
+ }
+ }
}
// Reset the user flags to their previous values:
// helper function for creating cells and subcells
const auto add_cell = [&](const unsigned int struct_dim,
- const auto & index_vertices,
+ const auto &index_vertices,
const unsigned int material_or_boundary_id,
const unsigned int manifold_id = 0) {
// sub-cell data only has to be stored if the information differs
template <int spacedim>
void
convert_hypercube_to_simplex_mesh(const Triangulation<1, spacedim> &in_tria,
- Triangulation<1, spacedim> & out_tria)
+ Triangulation<1, spacedim> &out_tria)
{
out_tria.copy_triangulation(in_tria);
return;
# else
typename ExtractBoundaryMesh<MeshType, dim, spacedim>::return_type
# endif
- extract_boundary_mesh(const MeshType<dim, spacedim> & volume_mesh,
- MeshType<dim - 1, spacedim> & surface_mesh,
+ extract_boundary_mesh(const MeshType<dim, spacedim> &volume_mesh,
+ MeshType<dim - 1, spacedim> &surface_mesh,
const std::set<types::boundary_id> &boundary_ids)
{
Assert((dynamic_cast<
template <int dim, int spacedim>
void
subdivided_hyper_rectangle_with_simplices(
- Triangulation<dim, spacedim> & tria,
+ Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &repetitions,
- const Point<dim> & p1,
- const Point<dim> & p2,
+ const Point<dim> &p1,
+ const Point<dim> &p2,
const bool colorize)
{
AssertDimension(dim, spacedim);
template void
replicate_triangulation(
const Triangulation<deal_II_dimension, deal_II_space_dimension> &input,
- const std::vector<unsigned int> & extents,
+ const std::vector<unsigned int> &extents,
Triangulation<deal_II_dimension, deal_II_space_dimension> &result);
template void
extract_boundary_mesh(
const Container<deal_II_dimension, deal_II_space_dimension> &mesh,
Container<deal_II_dimension - 1, deal_II_space_dimension>
- & boundary_mesh,
+ &boundary_mesh,
const std::set<types::boundary_id> &boundary_ids);
# endif
\}
template void GridGenerator::subdivided_hyper_rectangle_with_simplices(
Triangulation<deal_II_dimension> & tria,
const std::vector<unsigned int> &repetitions,
- const Point<deal_II_dimension> & p1,
- const Point<deal_II_dimension> & p2,
+ const Point<deal_II_dimension> &p1,
+ const Point<deal_II_dimension> &p2,
const bool colorize);
template void GridGenerator::subdivided_hyper_cube_with_simplices(
template <int dim>
void
implicit_function(Triangulation<dim, 3> &tria,
- const Function<3> & dealii_implicit_function,
+ const Function<3> &dealii_implicit_function,
const CGALWrappers::AdditionalData<dim> &data,
- const Point<3> & interior_point,
- const double & outer_ball_radius)
+ const Point<3> &interior_point,
+ const double &outer_ball_radius)
{
# ifdef DEAL_II_WITH_CGAL
Assert(dealii_implicit_function.n_components == 1,
void
surface_mesh_to_volumetric_mesh(const Triangulation<2, 3> &surface_tria,
- Triangulation<3> & vol_tria,
+ Triangulation<3> &vol_tria,
const CGALWrappers::AdditionalData<3> &data)
{
# ifdef DEAL_II_WITH_CGAL
void
parse_and_create(void (*generator)(Triangulation<dim, spacedim> &,
Arguments...),
- const std::string & arguments,
+ const std::string &arguments,
Triangulation<dim, spacedim> &tria)
{
std::function<void(Arguments...)> wrapper =
*/
template <int dim>
bool
- generate_codimension_zero_grid(const std::string & name,
- const std::string & arguments,
+ generate_codimension_zero_grid(const std::string &name,
+ const std::string &arguments,
Triangulation<dim> &tria)
{
if (name == "simplex")
*/
template <int dim>
bool
- generate_codimension_one_grid(const std::string & name,
- const std::string & arguments,
+ generate_codimension_one_grid(const std::string &name,
+ const std::string &arguments,
Triangulation<dim, dim + 1> &tria)
{
if (name == "hyper_sphere")
* Return true if a grid was actually generated, false otherwise.
*/
bool
- generate_special(const std::string & name,
- const std::string & arguments,
+ generate_special(const std::string &name,
+ const std::string &arguments,
Triangulation<3, 3> &tria)
{
if (name == "moebius")
* Return true if a grid was actually generated, false otherwise.
*/
bool
- generate_special(const std::string & name,
- const std::string & arguments,
+ generate_special(const std::string &name,
+ const std::string &arguments,
Triangulation<2, 3> &tria)
{
if (name == "torus")
template <int dim, int spacedim>
void
generate_from_name_and_arguments(Triangulation<dim, spacedim> &tria,
- const std::string & name,
- const std::string & arguments)
+ const std::string &name,
+ const std::string &arguments)
{
// We begin with all function calls that are implemented for all
// combinations of dim and spacedim.
//
// If one of the function call succeeds, we skip the rest and return.
else if (generate_codimension_zero_grid(name, arguments, tria))
- {}
+ {
+ }
else if (generate_codimension_one_grid(name, arguments, tria))
- {}
+ {
+ }
else if (generate_special(name, arguments, tria))
- {}
+ {
+ }
else
// If we got here, we really have no idea what grid the user wants to
// generate.
*/
Manifold(const Tensor<1, spacedim> &normal_direction,
const Tensor<1, spacedim> &direction,
- const Point<spacedim> & point_on_axis,
- const AdditionalData & data,
+ const Point<spacedim> &point_on_axis,
+ const AdditionalData &data,
const double tolerance = 1e-10);
/**
Manifold<dim, spacedim>::Manifold(
const Tensor<1, spacedim> &normal_direction,
const Tensor<1, spacedim> &direction,
- const Point<spacedim> & point_on_axis,
- const AdditionalData & data,
+ const Point<spacedim> &point_on_axis,
+ const AdditionalData &data,
const double tolerance)
: ChartManifold<dim, spacedim, 3>(Tensor<1, 3>({0, 2. * numbers::PI, 0}))
, normal_direction(normal_direction)
template <>
void
- pipe_junction(Triangulation<3, 3> & tria,
+ pipe_junction(Triangulation<3, 3> &tria,
const std::vector<std::pair<Point<3>, double>> &openings,
- const std::pair<Point<3>, double> & bifurcation,
+ const std::pair<Point<3>, double> &bifurcation,
const double aspect_ratio)
{
constexpr unsigned int dim = 3;
void
assign_1d_boundary_ids(
const std::vector<std::pair<Point<spacedim>, types::boundary_id>>
- & boundary_ids,
+ &boundary_ids,
Triangulation<1, spacedim> &triangulation)
{
for (auto &cell : triangulation.active_cell_iterators())
template <int dim, int spacedim>
void
apply_grid_fixup_functions(std::vector<Point<spacedim>> &vertices,
- std::vector<CellData<dim>> & cells,
- SubCellData & subcelldata)
+ std::vector<CellData<dim>> &cells,
+ SubCellData &subcelldata)
{
// check that no forbidden arrays are used
Assert(subcelldata.check_consistency(dim), ExcInternalError());
template <int dim, int spacedim>
void
GridIn<dim, spacedim>::parse_tecplot_header(
- std::string & header,
+ std::string &header,
std::vector<unsigned int> &tecplot2deal,
- unsigned int & n_vars,
- unsigned int & n_vertices,
- unsigned int & n_cells,
+ unsigned int &n_vars,
+ unsigned int &n_vertices,
+ unsigned int &n_cells,
std::vector<unsigned int> &IJK,
- bool & structured,
- bool & blocked)
+ bool &structured,
+ bool &blocked)
{
Assert(tecplot2deal.size() == dim, ExcInternalError());
Assert(IJK.size() == dim, ExcInternalError());
}
// Vertices
const unsigned int n_vertices = mesh->mNumVertices;
- const aiVector3D * mVertices = mesh->mVertices;
+ const aiVector3D *mVertices = mesh->mVertices;
// Faces
const unsigned int n_faces = mesh->mNumFaces;
- const aiFace * mFaces = mesh->mFaces;
+ const aiFace *mFaces = mesh->mFaces;
vertices.resize(v_offset + n_vertices);
cells.resize(c_offset + n_faces);
template <>
void
GridIn<2>::debug_output_grid(const std::vector<CellData<2>> &cells,
- const std::vector<Point<2>> & vertices,
- std::ostream & out)
+ const std::vector<Point<2>> &vertices,
+ std::ostream &out)
{
double min_x = vertices[cells[0].vertices[0]](0),
max_x = vertices[cells[0].vertices[0]](0),
template <>
void
GridIn<3>::debug_output_grid(const std::vector<CellData<3>> &cells,
- const std::vector<Point<3>> & vertices,
- std::ostream & out)
+ const std::vector<Point<3>> &vertices,
+ std::ostream &out)
{
for (const auto &cell : cells)
{
template <int dim, int spacedim>
void
GridOut::write_dx(const Triangulation<dim, spacedim> &tria,
- std::ostream & out) const
+ std::ostream &out) const
{
// TODO:[GK] allow for boundary faces only
Assert(dx_flags.write_all_faces, ExcNotImplemented());
AssertThrow(out.fail() == false, ExcIO());
// Copied and adapted from write_ucd
const std::vector<Point<spacedim>> &vertices = tria.get_vertices();
- const std::vector<bool> & vertex_used = tria.get_used_vertices();
+ const std::vector<bool> &vertex_used = tria.get_used_vertices();
const unsigned int n_vertices = tria.n_used_vertices();
// Write additional face information
if (write_faces)
- {}
+ {
+ }
else
- {}
+ {
+ }
// The wrapper
out << "object \"deal data\" class field" << '\n'
template <int dim, int spacedim>
void
GridOut::write_msh(const Triangulation<dim, spacedim> &tria,
- std::ostream & out) const
+ std::ostream &out) const
{
AssertThrow(out.fail() == false, ExcIO());
// vertices and whether they are
// used.
const std::vector<Point<spacedim>> &vertices = tria.get_vertices();
- const std::vector<bool> & vertex_used = tria.get_used_vertices();
+ const std::vector<bool> &vertex_used = tria.get_used_vertices();
const unsigned int n_vertices = tria.n_used_vertices();
template <int dim, int spacedim>
void
GridOut::write_ucd(const Triangulation<dim, spacedim> &tria,
- std::ostream & out) const
+ std::ostream &out) const
{
AssertThrow(out.fail() == false, ExcIO());
// vertices and whether they are
// used.
const std::vector<Point<spacedim>> &vertices = tria.get_vertices();
- const std::vector<bool> & vertex_used = tria.get_used_vertices();
+ const std::vector<bool> &vertex_used = tria.get_used_vertices();
const unsigned int n_vertices = tria.n_used_vertices();
// variables destroyed after
// use
std::time_t time1 = std::time(nullptr);
- std::tm * time = std::localtime(&time1);
+ std::tm *time = std::localtime(&time1);
out
<< "# This file was generated by the deal.II library." << '\n'
<< "# Date = " << time->tm_year + 1900 << "/" << time->tm_mon + 1
template <>
void
GridOut::write_xfig(const Triangulation<2> &tria,
- std::ostream & out,
+ std::ostream &out,
const Mapping<2> * /*mapping*/) const
{
const int dim = 2;
template <int dim, int spacedim>
void
GridOut::write_msh(const Triangulation<dim, spacedim> &tria,
- const std::string & filename) const
+ const std::string &filename) const
{
// mesh Type renumbering
const std::array<int, 8> dealii_to_gmsh_type = {{15, 1, 2, 3, 4, 7, 6, 5}};
// Extract all vertices (nodes in gmsh terminology), and store their three
// dimensional coordinates (regardless of dim).
- const auto & vertices = tria.get_vertices();
+ const auto &vertices = tria.get_vertices();
std::vector<double> coords(3 * vertices.size());
std::vector<std::size_t> nodes(vertices.size());
std::set<std::pair<int, int>> dim_entity_tag;
auto maybe_add_element =
- [&](const auto & element,
+ [&](const auto &element,
const types::boundary_id &boundary_or_material_id) {
const auto struct_dim = element->structure_dimension;
const auto manifold_id = element->manifold_id();
* For SVG output of grids.
*/
Point<2>
- svg_project_point(const Point<3> & point,
- const Point<3> & camera_position,
+ svg_project_point(const Point<3> &point,
+ const Point<3> &camera_position,
const Tensor<1, 3> &camera_direction,
const Tensor<1, 3> &camera_horizontal,
const float camera_focus)
template <int dim, int spacedim>
void
GridOut::write_mathgl(const Triangulation<dim, spacedim> &tria,
- std::ostream & out) const
+ std::ostream &out) const
{
AssertThrow(out.fail() == false, ExcIO());
{
// block this to have local variables destroyed after use
const std::time_t time1 = std::time(nullptr);
- const std::tm * time = std::localtime(&time1);
+ const std::tm *time = std::localtime(&time1);
out
<< "\n#"
template <int dim, int spacedim>
void
GridOut::write_vtk(const Triangulation<dim, spacedim> &tria,
- std::ostream & out) const
+ std::ostream &out) const
{
AssertThrow(out.fail() == false, ExcIO());
template <int dim, int spacedim>
void
GridOut::write_vtu(const Triangulation<dim, spacedim> &tria,
- std::ostream & out) const
+ std::ostream &out) const
{
AssertThrow(out.fail() == false, ExcIO());
void
GridOut::write_mesh_per_processor_as_vtu(
const Triangulation<dim, spacedim> &tria,
- const std::string & filename_without_extension,
+ const std::string &filename_without_extension,
const bool view_levels,
const bool include_artificial) const
{
unsigned int
GridOut::write_msh_faces(const Triangulation<dim, spacedim> &tria,
const unsigned int next_element_index,
- std::ostream & out) const
+ std::ostream &out) const
{
unsigned int current_element_index = next_element_index;
unsigned int
GridOut::write_msh_lines(const Triangulation<dim, spacedim> &tria,
const unsigned int next_element_index,
- std::ostream & out) const
+ std::ostream &out) const
{
unsigned int current_element_index = next_element_index;
// save the user flags for lines so
unsigned int
GridOut::write_ucd_faces(const Triangulation<dim, spacedim> &tria,
const unsigned int next_element_index,
- std::ostream & out) const
+ std::ostream &out) const
{
unsigned int current_element_index = next_element_index;
typename Triangulation<dim, spacedim>::active_face_iterator face, endf;
unsigned int
GridOut::write_ucd_lines(const Triangulation<dim, spacedim> &tria,
const unsigned int next_element_index,
- std::ostream & out) const
+ std::ostream &out) const
{
unsigned int current_element_index = next_element_index;
// save the user flags for lines so
template <int spacedim>
void
write_gnuplot(const dealii::Triangulation<1, spacedim> &tria,
- std::ostream & out,
+ std::ostream &out,
const Mapping<1, spacedim> *,
const GridOutFlags::Gnuplot &gnuplot_flags)
{
template <int spacedim>
void
write_gnuplot(const dealii::Triangulation<2, spacedim> &tria,
- std::ostream & out,
- const Mapping<2, spacedim> * mapping,
- const GridOutFlags::Gnuplot & gnuplot_flags)
+ std::ostream &out,
+ const Mapping<2, spacedim> *mapping,
+ const GridOutFlags::Gnuplot &gnuplot_flags)
{
AssertThrow(out.fail() == false, ExcIO());
template <int spacedim>
void
write_gnuplot(const dealii::Triangulation<3, spacedim> &tria,
- std::ostream & out,
- const Mapping<3, spacedim> * mapping,
- const GridOutFlags::Gnuplot & gnuplot_flags)
+ std::ostream &out,
+ const Mapping<3, spacedim> *mapping,
+ const GridOutFlags::Gnuplot &gnuplot_flags)
{
AssertThrow(out.fail() == false, ExcIO());
template <int dim, int spacedim>
void
GridOut::write_gnuplot(const Triangulation<dim, spacedim> &tria,
- std::ostream & out,
- const Mapping<dim, spacedim> * mapping) const
+ std::ostream &out,
+ const Mapping<dim, spacedim> *mapping) const
{
internal::write_gnuplot(tria, out, mapping, gnuplot_flags);
}
Point<2> second;
bool colorize;
unsigned int level;
- LineEntry(const Point<2> & f,
- const Point<2> & s,
+ LineEntry(const Point<2> &f,
+ const Point<2> &s,
const bool c,
const unsigned int l)
: first(f)
template <int dim, int spacedim>
void
write_eps(const dealii::Triangulation<dim, spacedim> &tria,
- std::ostream & out,
- const Mapping<dim, spacedim> * mapping,
- const GridOutFlags::Eps<2> & eps_flags_2,
- const GridOutFlags::Eps<3> & eps_flags_3)
+ std::ostream &out,
+ const Mapping<dim, spacedim> *mapping,
+ const GridOutFlags::Eps<2> &eps_flags_2,
+ const GridOutFlags::Eps<3> &eps_flags_3)
{
using LineList = std::list<LineEntry>;
// variables destroyed after
// use
std::time_t time1 = std::time(nullptr);
- std::tm * time = std::localtime(&time1);
+ std::tm *time = std::localtime(&time1);
out << "%!PS-Adobe-2.0 EPSF-1.2" << '\n'
<< "%%Title: deal.II Output" << '\n'
<< "%%Creator: the deal.II library" << '\n'
template <int dim, int spacedim>
void
GridOut::write_eps(const Triangulation<dim, spacedim> &tria,
- std::ostream & out,
- const Mapping<dim, spacedim> * mapping) const
+ std::ostream &out,
+ const Mapping<dim, spacedim> *mapping) const
{
internal::write_eps(tria, out, mapping, eps_flags_2, eps_flags_3);
}
template <int dim, int spacedim>
void
GridOut::write(const Triangulation<dim, spacedim> &tria,
- std::ostream & out,
+ std::ostream &out,
const OutputFormat output_format,
- const Mapping<dim, spacedim> * mapping) const
+ const Mapping<dim, spacedim> *mapping) const
{
switch (output_format)
{
template <int dim, int spacedim>
void
GridOut::write(const Triangulation<dim, spacedim> &tria,
- std::ostream & out,
- const Mapping<dim, spacedim> * mapping) const
+ std::ostream &out,
+ const Mapping<dim, spacedim> *mapping) const
{
write(tria, out, default_format, mapping);
}
void
refine_and_coarsen_fixed_fraction_via_l1_norm(
Triangulation<dim, spacedim> &tria,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double top_fraction,
const double bottom_fraction,
const unsigned int max_n_cells)
template <int dim, typename Number, int spacedim>
void
GridRefinement::refine(Triangulation<dim, spacedim> &tria,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double threshold,
const unsigned int max_to_mark)
{
template <int dim, typename Number, int spacedim>
void
GridRefinement::coarsen(Triangulation<dim, spacedim> &tria,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double threshold)
{
Assert(criteria.size() == tria.n_active_cells(),
void
GridRefinement::refine_and_coarsen_fixed_number(
Triangulation<dim, spacedim> &tria,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double top_fraction,
const double bottom_fraction,
const unsigned int max_n_cells)
void
GridRefinement::refine_and_coarsen_fixed_fraction(
Triangulation<dim, spacedim> &tria,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double top_fraction,
const double bottom_fraction,
const unsigned int max_n_cells,
template <int dim, int spacedim>
double
volume(const Triangulation<dim, spacedim> &triangulation,
- const Mapping<dim, spacedim> & mapping)
+ const Mapping<dim, spacedim> &mapping)
{
// get the degree of the mapping if possible. if not, just assume 1
unsigned int mapping_degree = 1;
template <int dim>
Vector<double>
- compute_aspect_ratio_of_cells(const Mapping<dim> & mapping,
+ compute_aspect_ratio_of_cells(const Mapping<dim> &mapping,
const Triangulation<dim> &triangulation,
- const Quadrature<dim> & quadrature)
+ const Quadrature<dim> &quadrature)
{
FE_Nothing<dim> fe;
FEValues<dim> fe_values(mapping, fe, quadrature, update_jacobians);
template <int dim>
double
- compute_maximum_aspect_ratio(const Mapping<dim> & mapping,
+ compute_maximum_aspect_ratio(const Mapping<dim> &mapping,
const Triangulation<dim> &triangulation,
- const Quadrature<dim> & quadrature)
+ const Quadrature<dim> &quadrature)
{
Vector<double> aspect_ratio_vector =
compute_aspect_ratio_of_cells(mapping, triangulation, quadrature);
template <int dim, int spacedim>
void
delete_unused_vertices(std::vector<Point<spacedim>> &vertices,
- std::vector<CellData<dim>> & cells,
- SubCellData & subcelldata)
+ std::vector<CellData<dim>> &cells,
+ SubCellData &subcelldata)
{
Assert(
subcelldata.check_consistency(dim),
template <int dim, int spacedim>
void
delete_duplicated_vertices(std::vector<Point<spacedim>> &vertices,
- std::vector<CellData<dim>> & cells,
- SubCellData & subcelldata,
- std::vector<unsigned int> & considered_vertices,
+ std::vector<CellData<dim>> &cells,
+ SubCellData &subcelldata,
+ std::vector<unsigned int> &considered_vertices,
const double tol)
{
if (tol == 0.0)
std::size_t
invert_cells_with_negative_measure(
const std::vector<Point<spacedim>> &all_vertices,
- std::vector<CellData<dim>> & cells)
+ std::vector<CellData<dim>> &cells)
{
// This function is presently only implemented for volumetric (codimension
// 0) elements.
void
invert_all_negative_measure_cells(
const std::vector<Point<spacedim>> &all_vertices,
- std::vector<CellData<dim>> & cells)
+ std::vector<CellData<dim>> &cells)
{
const std::size_t n_negative_cells =
invert_cells_with_negative_measure(all_vertices, cells);
template <int dim>
std::vector<Cell<dim>>
build_cells_and_connect_edges(const std::vector<CellData<dim>> &cells,
- std::vector<Edge<dim>> & edges)
+ std::vector<Edge<dim>> &edges)
{
std::vector<Cell<dim>> cell_list;
cell_list.reserve(cells.size());
template <int dim>
void
orient_one_set_of_parallel_edges(const std::vector<Cell<dim>> &cells,
- std::vector<Edge<dim>> & edges,
+ std::vector<Edge<dim>> &edges,
const unsigned int cell,
const unsigned int local_edge)
{
rotate_cell(const std::vector<Cell<dim>> &cell_list,
const std::vector<Edge<dim>> &edge_list,
const unsigned int cell_index,
- std::vector<CellData<dim>> & raw_cells)
+ std::vector<CellData<dim>> &raw_cells)
{
// find the first vertex of the cell. this is the vertex where dim edges
// originate, so for each of the edges record which the starting vertex is
template <int dim, int spacedim>
void
- shift(const Tensor<1, spacedim> & shift_vector,
+ shift(const Tensor<1, spacedim> &shift_vector,
Triangulation<dim, spacedim> &triangulation)
{
transform(internal::Shift<spacedim>(shift_vector), triangulation);
void
rotate(const Tensor<1, 3, double> &axis,
const double angle,
- Triangulation<dim, 3> & triangulation)
+ Triangulation<dim, 3> &triangulation)
{
transform(internal::Rotate3d(axis, angle), triangulation);
}
* in order to allow parallel execution.
*/
inline void
- laplace_solve(const SparseMatrix<double> & S,
+ laplace_solve(const SparseMatrix<double> &S,
const AffineConstraints<double> &constraints,
- Vector<double> & u)
+ Vector<double> &u)
{
const unsigned int n_dofs = S.n();
const auto op = linear_operator(S);
template <int dim>
void
laplace_transform(const std::map<unsigned int, Point<dim>> &new_points,
- Triangulation<dim> & triangulation,
- const Function<dim> * coefficient,
+ Triangulation<dim> &triangulation,
+ const Function<dim> *coefficient,
const bool solve_for_absolute_positions)
{
if (dim == 1)
for (const unsigned int vertex_no : cell->vertex_indices())
{
const unsigned int vertex_index = cell->vertex_index(vertex_no);
- const Point<dim> & vertex_point = cell->vertex(vertex_no);
+ const Point<dim> &vertex_point = cell->vertex(vertex_no);
const typename std::map<unsigned int, Point<dim>>::const_iterator
map_iter = new_points.find(vertex_index);
DEAL_II_CXX20_REQUIRES(
(concepts::is_triangulation_or_dof_handler<MeshType<dim, spacedim>>))
unsigned int find_closest_vertex(const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const std::vector<bool> &marked_vertices)
{
// first get the underlying triangulation from the mesh and determine
template <int dim, template <int, int> class MeshType, int spacedim>
DEAL_II_CXX20_REQUIRES(
(concepts::is_triangulation_or_dof_handler<MeshType<dim, spacedim>>))
- unsigned int find_closest_vertex(const Mapping<dim, spacedim> & mapping,
+ unsigned int find_closest_vertex(const Mapping<dim, spacedim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const std::vector<bool> &marked_vertices)
{
// Take a shortcut in the simple case.
compare_point_association(
const unsigned int a,
const unsigned int b,
- const Tensor<1, spacedim> & point_direction,
+ const Tensor<1, spacedim> &point_direction,
const std::vector<Tensor<1, spacedim>> ¢er_directions)
{
const double scalar_product_a = center_directions[a] * point_direction;
Point<dim>>
#endif
find_active_cell_around_point(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const std::vector<
std::set<typename MeshType<dim, spacedim>::active_cell_iterator>>
&vertex_to_cells,
const typename MeshType<dim, spacedim>::active_cell_iterator &cell_hint,
const std::vector<bool> &marked_vertices,
const RTree<std::pair<Point<spacedim>, unsigned int>>
- & used_vertices_rtree,
+ &used_vertices_rtree,
const double tolerance,
const RTree<
std::pair<BoundingBox<spacedim>,
unsigned int
find_closest_vertex_of_cell(
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
- const Point<spacedim> & position,
- const Mapping<dim, spacedim> & mapping)
+ const Point<spacedim> &position,
+ const Mapping<dim, spacedim> &mapping)
{
const auto vertices = mapping.get_vertices(cell);
double minimum_distance = position.distance_square(vertices[0]);
vector<BoundingBox<MeshType::space_dimension>> compute_mesh_predicate_bounding_box(
const MeshType &mesh,
const std::function<bool(const typename MeshType::active_cell_iterator &)>
- & predicate,
+ &predicate,
const unsigned int refinement_level,
const bool allow_merge,
const unsigned int max_boxes)
#endif
guess_point_owner(
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bboxes,
- const std::vector<Point<spacedim>> & points)
+ const std::vector<Point<spacedim>> &points)
{
unsigned int n_procs = global_bboxes.size();
std::vector<std::vector<unsigned int>> point_owners(n_procs);
#endif
guess_point_owner(
const RTree<std::pair<BoundingBox<spacedim>, unsigned int>> &covering_rtree,
- const std::vector<Point<spacedim>> & points)
+ const std::vector<Point<spacedim>> &points)
{
std::map<unsigned int, std::vector<unsigned int>> point_owners;
std::map<unsigned int, unsigned int> map_owners_found;
void
get_face_connectivity_of_cells(
const Triangulation<dim, spacedim> &triangulation,
- DynamicSparsityPattern & cell_connectivity)
+ DynamicSparsityPattern &cell_connectivity)
{
cell_connectivity.reinit(triangulation.n_active_cells(),
triangulation.n_active_cells());
void
get_vertex_connectivity_of_cells(
const Triangulation<dim, spacedim> &triangulation,
- DynamicSparsityPattern & cell_connectivity)
+ DynamicSparsityPattern &cell_connectivity)
{
std::vector<std::vector<unsigned int>> vertex_to_cell(
triangulation.n_vertices());
get_vertex_connectivity_of_cells_on_level(
const Triangulation<dim, spacedim> &triangulation,
const unsigned int level,
- DynamicSparsityPattern & cell_connectivity)
+ DynamicSparsityPattern &cell_connectivity)
{
std::vector<std::vector<unsigned int>> vertex_to_cell(
triangulation.n_vertices());
template <int dim, int spacedim>
void
partition_triangulation(const unsigned int n_partitions,
- Triangulation<dim, spacedim> & triangulation,
+ Triangulation<dim, spacedim> &triangulation,
const SparsityTools::Partitioner partitioner)
{
Assert((dynamic_cast<parallel::distributed::Triangulation<dim, spacedim> *>(
void
partition_triangulation(const unsigned int n_partitions,
const std::vector<unsigned int> &cell_weights,
- Triangulation<dim, spacedim> & triangulation,
+ Triangulation<dim, spacedim> &triangulation,
const SparsityTools::Partitioner partitioner)
{
Assert((dynamic_cast<parallel::distributed::Triangulation<dim, spacedim> *>(
template <int dim, int spacedim>
void
partition_triangulation(const unsigned int n_partitions,
- const SparsityPattern & cell_connection_graph,
+ const SparsityPattern &cell_connection_graph,
Triangulation<dim, spacedim> &triangulation,
const SparsityTools::Partitioner partitioner)
{
void
partition_triangulation(const unsigned int n_partitions,
const std::vector<unsigned int> &cell_weights,
- const SparsityPattern & cell_connection_graph,
+ const SparsityPattern &cell_connection_graph,
Triangulation<dim, spacedim> &triangulation,
const SparsityTools::Partitioner partitioner)
{
template <class IT>
void
set_subdomain_id_in_zorder_recursively(IT cell,
- unsigned int & current_proc_idx,
- unsigned int & current_cell_idx,
+ unsigned int ¤t_proc_idx,
+ unsigned int ¤t_cell_idx,
const unsigned int n_active_cells,
const unsigned int n_partitions)
{
void
get_subdomain_association(
const parallel::distributed::Triangulation<dim, spacedim>
- & triangulation,
- const std::vector<CellId> & cell_ids,
+ &triangulation,
+ const std::vector<CellId> &cell_ids,
std::vector<types::subdomain_id> &subdomain_ids)
{
#ifndef DEAL_II_WITH_P4EST
template <int dim, int spacedim>
std::vector<types::subdomain_id>
get_subdomain_association(const Triangulation<dim, spacedim> &triangulation,
- const std::vector<CellId> & cell_ids)
+ const std::vector<CellId> &cell_ids)
{
std::vector<types::subdomain_id> subdomain_ids;
subdomain_ids.reserve(cell_ids.size());
template <int dim, int spacedim>
void
get_subdomain_association(const Triangulation<dim, spacedim> &triangulation,
- std::vector<types::subdomain_id> & subdomain)
+ std::vector<types::subdomain_id> &subdomain)
{
Assert(subdomain.size() == triangulation.n_active_cells(),
ExcDimensionMismatch(subdomain.size(),
template <int dim, int spacedim>
double
minimal_cell_diameter(const Triangulation<dim, spacedim> &triangulation,
- const Mapping<dim, spacedim> & mapping)
+ const Mapping<dim, spacedim> &mapping)
{
double min_diameter = std::numeric_limits<double>::max();
for (const auto &cell : triangulation.active_cell_iterators())
template <int dim, int spacedim>
double
maximal_cell_diameter(const Triangulation<dim, spacedim> &triangulation,
- const Mapping<dim, spacedim> & mapping)
+ const Mapping<dim, spacedim> &mapping)
{
double max_diameter = 0.;
for (const auto &cell : triangulation.active_cell_iterators())
// function
template <typename Iterator, int spacedim>
double
- objective_function(const Iterator & object,
+ objective_function(const Iterator &object,
const Point<spacedim> &object_mid_point)
{
const unsigned int structdim =
*/
template <typename Iterator>
Point<Iterator::AccessorType::space_dimension>
- get_face_midpoint(const Iterator & object,
+ get_face_midpoint(const Iterator &object,
const unsigned int f,
std::integral_constant<int, 1>)
{
*/
template <typename Iterator>
Point<Iterator::AccessorType::space_dimension>
- get_face_midpoint(const Iterator & object,
+ get_face_midpoint(const Iterator &object,
const unsigned int f,
std::integral_constant<int, 2>)
{
*/
template <typename Iterator>
Point<Iterator::AccessorType::space_dimension>
- get_face_midpoint(const Iterator & object,
+ get_face_midpoint(const Iterator &object,
const unsigned int f,
std::integral_constant<int, 3>)
{
map_boundary_to_manifold_ids(
const std::vector<types::boundary_id> &src_boundary_ids,
const std::vector<types::manifold_id> &dst_manifold_ids,
- Triangulation<dim, spacedim> & tria,
+ Triangulation<dim, spacedim> &tria,
const std::vector<types::boundary_id> &reset_boundary_ids_)
{
AssertDimension(src_boundary_ids.size(), dst_manifold_ids.size());
template <int dim, int spacedim>
void
assign_co_dimensional_manifold_indicators(
- Triangulation<dim, spacedim> & tria,
+ Triangulation<dim, spacedim> &tria,
const std::function<types::manifold_id(
const std::set<types::manifold_id> &)> &disambiguation_function,
bool overwrite_only_flat_manifold_ids)
return_type
#endif
compute_point_locations(
- const Cache<dim, spacedim> & cache,
+ const Cache<dim, spacedim> &cache,
const std::vector<Point<spacedim>> &points,
const typename Triangulation<dim, spacedim>::active_cell_iterator
&cell_hint)
return_type
#endif
compute_point_locations_try_all(
- const Cache<dim, spacedim> & cache,
+ const Cache<dim, spacedim> &cache,
const std::vector<Point<spacedim>> &points,
const typename Triangulation<dim, spacedim>::active_cell_iterator
&cell_hint)
const auto store_cell_point_and_id =
[&](
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
- const Point<dim> & ref_point,
+ const Point<dim> &ref_point,
const unsigned int &id) {
const auto it = std::find(cells_out.rbegin(), cells_out.rend(), cell);
if (it != cells_out.rend())
return_type
#endif
distributed_compute_point_locations(
- const GridTools::Cache<dim, spacedim> & cache,
- const std::vector<Point<spacedim>> & points,
+ const GridTools::Cache<dim, spacedim> &cache,
+ const std::vector<Point<spacedim>> &points,
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bboxes,
const double tolerance,
- const std::vector<bool> & marked_vertices,
+ const std::vector<bool> &marked_vertices,
const bool enforce_unique_mapping)
{
// run internal function ...
guess_owners_of_entities(
const MPI_Comm comm,
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bboxes,
- const std::vector<T> & entities,
+ const std::vector<T> &entities,
const double tolerance)
{
std::vector<std::pair<unsigned int, unsigned int>> ranks_and_indices;
std::pair<typename Triangulation<dim, spacedim>::active_cell_iterator,
Point<dim>>>
find_all_locally_owned_active_cells_around_point(
- const Cache<dim, spacedim> & cache,
- const Point<spacedim> & point,
+ const Cache<dim, spacedim> &cache,
+ const Point<spacedim> &point,
typename Triangulation<dim, spacedim>::active_cell_iterator &cell_hint,
const std::vector<bool> &marked_vertices,
const double tolerance,
template <int dim, int spacedim>
DistributedComputePointLocationsInternal<dim, spacedim>
distributed_compute_point_locations(
- const GridTools::Cache<dim, spacedim> & cache,
- const std::vector<Point<spacedim>> & points,
+ const GridTools::Cache<dim, spacedim> &cache,
+ const std::vector<Point<spacedim>> &points,
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bboxes,
- const std::vector<bool> & marked_vertices,
+ const std::vector<bool> &marked_vertices,
const double tolerance,
const bool perform_handshake,
const bool enforce_unique_mapping)
const auto answer_request =
[&](const unsigned int &other_rank,
- const RequestType & request) -> AnswerType {
+ const RequestType &request) -> AnswerType {
AnswerType answer(request.size(), 0);
if (has_relevant_vertices)
};
const auto process_answer = [&](const unsigned int other_rank,
- const AnswerType & answer) {
+ const AnswerType &answer) {
if (perform_handshake)
{
const auto other_rank_index = translate(other_rank);
convert_to_distributed_compute_point_locations_internal(
const unsigned int n_points_1D,
const Triangulation<dim, spacedim> &tria,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const bool consistent_numbering_of_sender_and_receiver) const
{
using CellIterator =
DistributedComputeIntersectionLocationsInternal<structdim, spacedim>::
communicate_indices(
const std::vector<std::tuple<unsigned int, unsigned int, unsigned int>>
- & point_recv_components,
+ &point_recv_components,
const MPI_Comm comm) const
{
#ifndef DEAL_II_WITH_MPI
template <int structdim, int dim, int spacedim>
DistributedComputeIntersectionLocationsInternal<structdim, spacedim>
distributed_compute_intersection_locations(
- const Cache<dim, spacedim> & cache,
+ const Cache<dim, spacedim> &cache,
const std::vector<std::vector<Point<spacedim>>> &intersection_requests,
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bboxes,
- const std::vector<bool> & marked_vertices,
+ const std::vector<bool> &marked_vertices,
const double tolerance)
{
using IntersectionRequest = std::vector<Point<spacedim>>;
const auto answer_request =
[&](const unsigned int &other_rank,
- const RequestType & request) -> AnswerType {
+ const RequestType &request) -> AnswerType {
AnswerType answer;
if (has_relevant_vertices)
};
const auto process_answer = [&](const unsigned int other_rank,
- const AnswerType & answer) {
+ const AnswerType &answer) {
for (unsigned int i = 0; i < answer.size(); ++i)
recv_components.emplace_back(other_rank,
answer[i].first,
template <int dim, int spacedim>
std::map<unsigned int, Point<spacedim>>
extract_used_vertices(const Triangulation<dim, spacedim> &container,
- const Mapping<dim, spacedim> & mapping)
+ const Mapping<dim, spacedim> &mapping)
{
std::map<unsigned int, Point<spacedim>> result;
for (const auto &cell : container.active_cell_iterators())
template <int spacedim>
unsigned int
find_closest_vertex(const std::map<unsigned int, Point<spacedim>> &vertices,
- const Point<spacedim> & p)
+ const Point<spacedim> &p)
{
auto id_and_v = std::min_element(
vertices.begin(),
Point<dim>>
find_active_cell_around_point(
const Cache<dim, spacedim> &cache,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const typename Triangulation<dim, spacedim>::active_cell_iterator
- & cell_hint,
+ &cell_hint,
const std::vector<bool> &marked_vertices,
const double tolerance)
{
template <int dim, int spacedim>
void
collect_coinciding_vertices(
- const Triangulation<dim, spacedim> & tria,
+ const Triangulation<dim, spacedim> &tria,
std::map<unsigned int, std::vector<unsigned int>> &coinciding_vertex_groups,
std::map<unsigned int, unsigned int> &vertex_to_coinciding_vertex_group)
{
typename value_type>
void
process_sub_cell(
- const std::array<unsigned int, n_configurations> & cut_line_table,
+ const std::array<unsigned int, n_configurations> &cut_line_table,
const ndarray<unsigned int, n_configurations, n_cols> &new_line_table,
- const ndarray<unsigned int, n_lines, 2> & line_to_vertex_table,
- const std::vector<value_type> & ls_values,
- const std::vector<Point<dim>> & points,
- const std::vector<unsigned int> & mask,
+ const ndarray<unsigned int, n_lines, 2> &line_to_vertex_table,
+ const std::vector<value_type> &ls_values,
+ const std::vector<Point<dim>> &points,
+ const std::vector<unsigned int> &mask,
const double iso_level,
const double tolerance,
- std::vector<Point<dim>> & vertices,
+ std::vector<Point<dim>> &vertices,
std::vector<CellData<dim == 1 ? 1 : dim - 1>> &cells,
const bool write_back_cell_data)
{
template <int dim, typename VectorType>
MarchingCubeAlgorithm<dim, VectorType>::MarchingCubeAlgorithm(
- const Mapping<dim, dim> & mapping,
+ const Mapping<dim, dim> &mapping,
const FiniteElement<dim, dim> &fe,
const unsigned int n_subdivisions,
const double tolerance)
template <int dim, typename VectorType>
void
MarchingCubeAlgorithm<dim, VectorType>::process(
- const DoFHandler<dim> & background_dof_handler,
- const VectorType & ls_vector,
+ const DoFHandler<dim> &background_dof_handler,
+ const VectorType &ls_vector,
const double iso_level,
- std::vector<Point<dim>> & vertices,
+ std::vector<Point<dim>> &vertices,
std::vector<CellData<dim == 1 ? 1 : dim - 1>> &cells) const
{
AssertThrow(
template <int dim, typename VectorType>
void
MarchingCubeAlgorithm<dim, VectorType>::process(
- const DoFHandler<dim> & background_dof_handler,
- const VectorType & ls_vector,
+ const DoFHandler<dim> &background_dof_handler,
+ const VectorType &ls_vector,
const double iso_level,
std::vector<Point<dim>> &vertices) const
{
void
MarchingCubeAlgorithm<dim, VectorType>::process_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- const VectorType & ls_vector,
+ const VectorType &ls_vector,
const double iso_level,
- std::vector<Point<dim>> & vertices,
- std::vector<CellData<dim == 1 ? 1 : dim - 1>> & cells) const
+ std::vector<Point<dim>> &vertices,
+ std::vector<CellData<dim == 1 ? 1 : dim - 1>> &cells) const
{
AssertThrow(
dim > 1,
void
MarchingCubeAlgorithm<dim, VectorType>::process_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- const VectorType & ls_vector,
+ const VectorType &ls_vector,
const double iso_level,
- std::vector<Point<dim>> & vertices) const
+ std::vector<Point<dim>> &vertices) const
{
// This vector is just a placeholder to reuse the process_cell function.
std::vector<CellData<dim == 1 ? 1 : dim - 1>> dummy_cells;
template <int dim, typename VectorType>
void
MarchingCubeAlgorithm<dim, VectorType>::process_cell(
- std::vector<value_type> & ls_values,
- const std::vector<Point<dim>> & points,
+ std::vector<value_type> &ls_values,
+ const std::vector<Point<dim>> &points,
const double iso_level,
- std::vector<Point<dim>> & vertices,
+ std::vector<Point<dim>> &vertices,
std::vector<CellData<dim == 1 ? 1 : dim - 1>> &cells,
const bool write_back_cell_data) const
{
template <int dim, typename VectorType>
void
MarchingCubeAlgorithm<dim, VectorType>::process_sub_cell(
- const std::vector<value_type> & ls_values,
- const std::vector<Point<2>> & points,
+ const std::vector<value_type> &ls_values,
+ const std::vector<Point<2>> &points,
const std::vector<unsigned int> &mask,
const double iso_level,
- std::vector<Point<2>> & vertices,
- std::vector<CellData<1>> & cells,
+ std::vector<Point<2>> &vertices,
+ std::vector<CellData<1>> &cells,
const bool write_back_cell_data) const
{
// set up dimension-dependent sizes and tables
template <int dim, typename VectorType>
void
MarchingCubeAlgorithm<dim, VectorType>::process_sub_cell(
- const std::vector<value_type> & ls_values,
- const std::vector<Point<3>> & points,
+ const std::vector<value_type> &ls_values,
+ const std::vector<Point<3>> &points,
const std::vector<unsigned int> &mask,
const double iso_level,
- std::vector<Point<3>> & vertices,
- std::vector<CellData<2>> & cells,
+ std::vector<Point<3>> &vertices,
+ std::vector<CellData<2>> &cells,
const bool write_back_cell_data) const
{
// set up dimension-dependent sizes and tables
template unsigned int GridTools::find_closest_vertex(
const std::map<unsigned int, Point<deal_II_space_dimension>> &vertices,
- const Point<deal_II_space_dimension> & p);
+ const Point<deal_II_space_dimension> &p);
template std::vector<std::vector<BoundingBox<deal_II_space_dimension>>>
GridTools::exchange_local_bounding_boxes(
template void
get_face_connectivity_of_cells(
const Triangulation<deal_II_dimension, deal_II_space_dimension>
- & triangulation,
+ &triangulation,
DynamicSparsityPattern &cell_connectivity);
template void
get_vertex_connectivity_of_cells(
const Triangulation<deal_II_dimension, deal_II_space_dimension>
- & triangulation,
+ &triangulation,
DynamicSparsityPattern &cell_connectivity);
template void
get_vertex_connectivity_of_cells_on_level(
const Triangulation<deal_II_dimension, deal_II_space_dimension>
- & triangulation,
+ &triangulation,
const unsigned int level,
DynamicSparsityPattern &cell_connectivity);
template void
laplace_transform(
const std::map<unsigned int, Point<deal_II_dimension>> &new_points,
- Triangulation<deal_II_dimension> & triangulation,
- const Function<deal_II_dimension> * coefficient,
+ Triangulation<deal_II_dimension> &triangulation,
+ const Function<deal_II_dimension> *coefficient,
const bool);
template Triangulation<deal_II_dimension,
{
template <int dim, int spacedim>
Cache<dim, spacedim>::Cache(const Triangulation<dim, spacedim> &tria,
- const Mapping<dim, spacedim> & mapping)
+ const Mapping<dim, spacedim> &mapping)
: update_flags(update_all)
, tria(&tria)
, mapping(&mapping)
DEAL_II_CXX20_REQUIRES(
(concepts::is_triangulation_or_dof_handler<MeshType<dim, spacedim>>))
unsigned int find_closest_vertex(const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const std::vector<bool> &marked_vertices)
{
// first get the underlying
template <int dim, template <int, int> class MeshType, int spacedim>
DEAL_II_CXX20_REQUIRES(
(concepts::is_triangulation_or_dof_handler<MeshType<dim, spacedim>>))
- unsigned int find_closest_vertex(const Mapping<dim, spacedim> & mapping,
+ unsigned int find_closest_vertex(const Mapping<dim, spacedim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const std::vector<bool> &marked_vertices)
{
// Take a shortcut in the simple case.
MeshType::space_dimension,
MeshType>::type>
#endif
- find_cells_adjacent_to_vertex(const MeshType & mesh,
+ find_cells_adjacent_to_vertex(const MeshType &mesh,
const unsigned int vertex)
{
const int dim = MeshType::dimension;
ActiveCellIterator<dim, spacedim, MeshType<dim, spacedim>>::type
#endif
find_active_cell_around_point(const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const std::vector<bool> &marked_vertices,
const double tolerance)
{
ActiveCellIterator<dim, spacedim, MeshType<dim, spacedim>>::type,
Point<dim>>
#endif
- find_active_cell_around_point(const Mapping<dim, spacedim> & mapping,
+ find_active_cell_around_point(const Mapping<dim, spacedim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const std::vector<bool> &marked_vertices,
const double tolerance)
{
ActiveCellIterator<dim, spacedim, MeshType<dim, spacedim>>::type,
Point<dim>>>
#endif
- find_all_active_cells_around_point(const Mapping<dim, spacedim> & mapping,
+ find_all_active_cells_around_point(const Mapping<dim, spacedim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const double tolerance,
const std::vector<bool> &marked_vertices)
{
Point<dim>>>
#endif
find_all_active_cells_around_point(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const MeshType<dim, spacedim> &mesh,
- const Point<spacedim> & p,
+ const Point<spacedim> &p,
const double tolerance,
const std::pair<typename MeshType<dim, spacedim>::active_cell_iterator,
- Point<dim>> & first_cell,
+ Point<dim>> &first_cell,
const std::vector<
std::set<typename MeshType<dim, spacedim>::active_cell_iterator>>
*vertex_to_cells)
vector<typename MeshType::cell_iterator> compute_cell_halo_layer_on_level(
const MeshType &mesh,
const std::function<bool(const typename MeshType::cell_iterator &)>
- & predicate,
+ &predicate,
const unsigned int level)
{
std::vector<typename MeshType::cell_iterator> level_halo_layer;
vector<typename MeshType::active_cell_iterator> compute_active_cell_layer_within_distance(
const MeshType &mesh,
const std::function<bool(const typename MeshType::active_cell_iterator &)>
- & predicate,
+ &predicate,
const double layer_thickness)
{
std::vector<typename MeshType::active_cell_iterator>
Point<dim>>
find_active_cell_around_point(
const hp::MappingCollection<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> & mesh,
- const Point<spacedim> & p,
+ const DoFHandler<dim, spacedim> &mesh,
+ const Point<spacedim> &p,
const double tolerance)
{
Assert((mapping.size() == 1) ||
// children of the neighbor because they can not be further refined
// and, consequently, the children is active
if (MeshType::dimension > 1)
- {
- for (unsigned int subface = 0;
- subface < cell->face(face_number)->n_children();
- ++subface)
- patch.push_back(
- cell->neighbor_child_on_subface(face_number, subface));
- }
- else
- {
- // in 1d, we need to work a bit harder: iterate until we find
- // the child by going from cell to child to child etc
- typename MeshType::cell_iterator neighbor =
- cell->neighbor(face_number);
- while (neighbor->has_children())
- neighbor = neighbor->child(1 - face_number);
-
- Assert(neighbor->neighbor(1 - face_number) == cell,
- ExcInternalError());
- patch.push_back(neighbor);
- }
+ {
+ for (unsigned int subface = 0;
+ subface < cell->face(face_number)->n_children();
+ ++subface)
+ patch.push_back(
+ cell->neighbor_child_on_subface(face_number, subface));
+ }
+ else
+ {
+ // in 1d, we need to work a bit harder: iterate until we find
+ // the child by going from cell to child to child etc
+ typename MeshType::cell_iterator neighbor =
+ cell->neighbor(face_number);
+ while (neighbor->has_children())
+ neighbor = neighbor->child(1 - face_number);
+
+ Assert(neighbor->neighbor(1 - face_number) == cell,
+ ExcInternalError());
+ patch.push_back(neighbor);
+ }
}
return patch;
}
match_periodic_face_pairs(
std::set<std::pair<CellIterator, unsigned int>> &pairs1,
std::set<std::pair<std_cxx20::type_identity_t<CellIterator>, unsigned int>>
- & pairs2,
+ &pairs2,
const unsigned int direction,
std::vector<PeriodicFacePair<CellIterator>> &matched_pairs,
const dealii::Tensor<1, CellIterator::AccessorType::space_dimension>
- & offset,
+ &offset,
const FullMatrix<double> &matrix)
{
static const int space_dim = CellIterator::AccessorType::space_dimension;
template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void collect_periodic_faces(
- const MeshType & mesh,
+ const MeshType &mesh,
const types::boundary_id b_id,
const unsigned int direction,
std::vector<PeriodicFacePair<typename MeshType::cell_iterator>>
- & matched_pairs,
+ &matched_pairs,
const Tensor<1, MeshType::space_dimension> &offset,
- const FullMatrix<double> & matrix)
+ const FullMatrix<double> &matrix)
{
static const int dim = MeshType::dimension;
static const int space_dim = MeshType::space_dimension;
template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void collect_periodic_faces(
- const MeshType & mesh,
+ const MeshType &mesh,
const types::boundary_id b_id1,
const types::boundary_id b_id2,
const unsigned int direction,
std::vector<PeriodicFacePair<typename MeshType::cell_iterator>>
- & matched_pairs,
+ &matched_pairs,
const Tensor<1, MeshType::space_dimension> &offset,
- const FullMatrix<double> & matrix)
+ const FullMatrix<double> &matrix)
{
static const int dim = MeshType::dimension;
static const int space_dim = MeshType::space_dimension;
*/
template <int spacedim>
inline bool
- orthogonal_equality(const Point<spacedim> & point1,
- const Point<spacedim> & point2,
+ orthogonal_equality(const Point<spacedim> &point1,
+ const Point<spacedim> &point2,
const unsigned int direction,
const Tensor<1, spacedim> &offset,
- const FullMatrix<double> & matrix)
+ const FullMatrix<double> &matrix)
{
AssertIndexRange(direction, spacedim);
template <typename FaceIterator>
inline bool
orthogonal_equality(
- std::bitset<3> & orientation,
- const FaceIterator & face1,
- const FaceIterator & face2,
+ std::bitset<3> &orientation,
+ const FaceIterator &face1,
+ const FaceIterator &face2,
const unsigned int direction,
const Tensor<1, FaceIterator::AccessorType::space_dimension> &offset,
- const FullMatrix<double> & matrix)
+ const FullMatrix<double> &matrix)
{
Assert(matrix.m() == matrix.n(),
ExcMessage("The supplied matrix must be a square matrix"));
template <typename FaceIterator>
inline bool
orthogonal_equality(
- const FaceIterator & face1,
- const FaceIterator & face2,
+ const FaceIterator &face1,
+ const FaceIterator &face2,
const unsigned int direction,
const Tensor<1, FaceIterator::AccessorType::space_dimension> &offset,
- const FullMatrix<double> & matrix)
+ const FullMatrix<double> &matrix)
{
// Call the function above with a dummy orientation array
std::bitset<3> dummy;
{
template <>
double
- cell_measure<1>(const std::vector<Point<1>> & all_vertices,
+ cell_measure<1>(const std::vector<Point<1>> &all_vertices,
const ArrayView<const unsigned int> &vertex_indices)
{
AssertDimension(vertex_indices.size(), GeometryInfo<1>::vertices_per_cell);
template <>
double
- cell_measure<2>(const std::vector<Point<2>> & all_vertices,
+ cell_measure<2>(const std::vector<Point<2>> &all_vertices,
const ArrayView<const unsigned int> &vertex_indices)
{
if (vertex_indices.size() == 3) // triangle
template <>
double
- cell_measure<3>(const std::vector<Point<3>> & all_vertices,
+ cell_measure<3>(const std::vector<Point<3>> &all_vertices,
const ArrayView<const unsigned int> &vertex_indices)
{
if (vertex_indices.size() == 4) // tetrahedron
Point<spacedim>
Manifold<dim, spacedim>::get_new_point(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights) const
+ const ArrayView<const double> &weights) const
{
const double tol = 1e-10;
const unsigned int n_points = surrounding_points.size();
void
Manifold<dim, spacedim>::get_new_points(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Table<2, double> & weights,
+ const Table<2, double> &weights,
ArrayView<Point<spacedim>> new_points) const
{
AssertDimension(surrounding_points.size(), weights.size(1));
template <>
Tensor<1, 2>
Manifold<2, 2>::normal_vector(const Triangulation<2, 2>::face_iterator &face,
- const Point<2> & p) const
+ const Point<2> &p) const
{
const int spacedim = 2;
template <>
Tensor<1, 3>
Manifold<3, 3>::normal_vector(const Triangulation<3, 3>::face_iterator &face,
- const Point<3> & p) const
+ const Point<3> &p) const
{
const int spacedim = 3;
void
Manifold<2, 2>::get_normals_at_vertices(
const Triangulation<2, 2>::face_iterator &face,
- FaceVertexNormals & n) const
+ FaceVertexNormals &n) const
{
n[0] = cross_product_2d(get_tangent_vector(face->vertex(0), face->vertex(1)));
n[1] =
void
Manifold<3, 3>::get_normals_at_vertices(
const Triangulation<3, 3>::face_iterator &face,
- FaceVertexNormals & n) const
+ FaceVertexNormals &n) const
{
n[0] = cross_product_3d(get_tangent_vector(face->vertex(0), face->vertex(1)),
get_tangent_vector(face->vertex(0), face->vertex(2)));
void
Manifold<dim, spacedim>::get_normals_at_vertices(
const typename Triangulation<dim, spacedim>::face_iterator &face,
- FaceVertexNormals & n) const
+ FaceVertexNormals &n) const
{
for (unsigned int v = 0; v < face->reference_cell().n_vertices(); ++v)
{
Point<spacedim>
FlatManifold<dim, spacedim>::get_new_point(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights) const
+ const ArrayView<const double> &weights) const
{
Assert(std::abs(std::accumulate(weights.begin(), weights.end(), 0.0) - 1.0) <
1e-10,
void
FlatManifold<dim, spacedim>::get_new_points(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Table<2, double> & weights,
+ const Table<2, double> &weights,
ArrayView<Point<spacedim>> new_points) const
{
AssertDimension(surrounding_points.size(), weights.size(1));
void
FlatManifold<2>::get_normals_at_vertices(
const Triangulation<2>::face_iterator &face,
- Manifold<2, 2>::FaceVertexNormals & face_vertex_normals) const
+ Manifold<2, 2>::FaceVertexNormals &face_vertex_normals) const
{
const Tensor<1, 2> tangent = face->vertex(1) - face->vertex(0);
// We're in 2d. Faces are edges:
void
FlatManifold<3>::get_normals_at_vertices(
const Triangulation<3>::face_iterator &face,
- Manifold<3, 3>::FaceVertexNormals & face_vertex_normals) const
+ Manifold<3, 3>::FaceVertexNormals &face_vertex_normals) const
{
const unsigned int vertices_per_face = GeometryInfo<3>::vertices_per_face;
Tensor<1, 2>
FlatManifold<2, 2>::normal_vector(
const Triangulation<2, 2>::face_iterator &face,
- const Point<2> & p) const
+ const Point<2> &p) const
{
// In 2d, a face is just a straight line and
// we can use the 'standard' implementation.
Tensor<1, spacedim>
FlatManifold<dim, spacedim>::normal_vector(
const typename Triangulation<dim, spacedim>::face_iterator &face,
- const Point<spacedim> & p) const
+ const Point<spacedim> &p) const
{
// I don't think the implementation below will work when dim!=spacedim;
// in fact, I believe that we don't even have enough information here,
Point<spacedim>
ChartManifold<dim, spacedim, chartdim>::get_new_point(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights) const
+ const ArrayView<const double> &weights) const
{
const std::size_t n_points = surrounding_points.size();
void
ChartManifold<dim, spacedim, chartdim>::get_new_points(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Table<2, double> & weights,
+ const Table<2, double> &weights,
ArrayView<Point<spacedim>> new_points) const
{
Assert(weights.size(0) > 0, ExcEmptyObject());
bool
spherical_face_is_horizontal(
const typename Triangulation<dim, spacedim>::face_iterator &face,
- const Point<spacedim> & manifold_center)
+ const Point<spacedim> &manifold_center)
{
// We test whether a face is horizontal by checking that the vertices
// all have roughly the same distance from the center: If the
Tensor<1, spacedim>
PolarManifold<dim, spacedim>::normal_vector(
const typename Triangulation<dim, spacedim>::face_iterator &face,
- const Point<spacedim> & p) const
+ const Point<spacedim> &p) const
{
// Let us first test whether we are on a "horizontal" face
// (tangential to the sphere). In this case, the normal vector is
Tensor<1, spacedim>
SphericalManifold<dim, spacedim>::normal_vector(
const typename Triangulation<dim, spacedim>::face_iterator &face,
- const Point<spacedim> & p) const
+ const Point<spacedim> &p) const
{
// Let us first test whether we are on a "horizontal" face
// (tangential to the sphere). In this case, the normal vector is
void
SphericalManifold<dim, spacedim>::get_new_points(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Table<2, double> & weights,
+ const Table<2, double> &weights,
ArrayView<Point<spacedim>> new_points) const
{
AssertDimension(new_points.size(), weights.size(0));
Point<spacedim>
SphericalManifold<dim, spacedim>::get_new_point(
const ArrayView<const Point<spacedim>> &vertices,
- const ArrayView<const double> & weights) const
+ const ArrayView<const double> &weights) const
{
// To avoid duplicating all of the logic in get_new_points, simply call it
// for one position.
void
SphericalManifold<dim, spacedim>::get_new_points(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights,
+ const ArrayView<const double> &weights,
ArrayView<Point<spacedim>> new_points) const
{
AssertDimension(weights.size(),
std::pair<double, Tensor<1, spacedim>>
SphericalManifold<dim, spacedim>::guess_new_point(
const ArrayView<const Tensor<1, spacedim>> &directions,
- const ArrayView<const double> & distances,
- const ArrayView<const double> & weights) const
+ const ArrayView<const double> &distances,
+ const ArrayView<const double> &weights) const
{
const double tolerance = 1e-10;
double rho = 0.;
template <>
Point<3>
do_get_new_point(const ArrayView<const Tensor<1, 3>> &directions,
- const ArrayView<const double> & distances,
- const ArrayView<const double> & weights,
- const Point<3> & candidate_point)
+ const ArrayView<const double> &distances,
+ const ArrayView<const double> &weights,
+ const Point<3> &candidate_point)
{
(void)distances;
Point<3>
SphericalManifold<1, 3>::get_new_point(
const ArrayView<const Tensor<1, 3>> &directions,
- const ArrayView<const double> & distances,
- const ArrayView<const double> & weights,
- const Point<3> & candidate_point) const
+ const ArrayView<const double> &distances,
+ const ArrayView<const double> &weights,
+ const Point<3> &candidate_point) const
{
return do_get_new_point(directions, distances, weights, candidate_point);
}
Point<3>
SphericalManifold<2, 3>::get_new_point(
const ArrayView<const Tensor<1, 3>> &directions,
- const ArrayView<const double> & distances,
- const ArrayView<const double> & weights,
- const Point<3> & candidate_point) const
+ const ArrayView<const double> &distances,
+ const ArrayView<const double> &weights,
+ const Point<3> &candidate_point) const
{
return do_get_new_point(directions, distances, weights, candidate_point);
}
Point<3>
SphericalManifold<3, 3>::get_new_point(
const ArrayView<const Tensor<1, 3>> &directions,
- const ArrayView<const double> & distances,
- const ArrayView<const double> & weights,
- const Point<3> & candidate_point) const
+ const ArrayView<const double> &distances,
+ const ArrayView<const double> &weights,
+ const Point<3> &candidate_point) const
{
return do_get_new_point(directions, distances, weights, candidate_point);
}
template <int dim, int spacedim>
CylindricalManifold<dim, spacedim>::CylindricalManifold(
const Tensor<1, spacedim> &direction,
- const Point<spacedim> & point_on_axis,
+ const Point<spacedim> &point_on_axis,
const double tolerance)
: ChartManifold<dim, spacedim, 3>(Tensor<1, 3>({0, 2. * numbers::PI, 0}))
, normal_direction(internal::compute_normal(direction, true))
Point<spacedim>
CylindricalManifold<dim, spacedim>::get_new_point(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights) const
+ const ArrayView<const double> &weights) const
{
Assert(spacedim == 3,
ExcMessage("CylindricalManifold can only be used for spacedim==3!"));
// ============================================================
template <int dim, int spacedim>
EllipticalManifold<dim, spacedim>::EllipticalManifold(
- const Point<spacedim> & center,
+ const Point<spacedim> ¢er,
const Tensor<1, spacedim> &major_axis_direction,
const double eccentricity)
: ChartManifold<dim, spacedim, spacedim>(
// ============================================================
template <int dim, int spacedim, int chartdim>
FunctionManifold<dim, spacedim, chartdim>::FunctionManifold(
- const Function<chartdim> & push_forward_function,
- const Function<spacedim> & pull_back_function,
+ const Function<chartdim> &push_forward_function,
+ const Function<spacedim> &pull_back_function,
const Tensor<1, chartdim> &periodicity,
const double tolerance)
: ChartManifold<dim, spacedim, chartdim>(periodicity)
FunctionManifold<dim, spacedim, chartdim>::FunctionManifold(
std::unique_ptr<Function<chartdim>> push_forward,
std::unique_ptr<Function<spacedim>> pull_back,
- const Tensor<1, chartdim> & periodicity,
+ const Tensor<1, chartdim> &periodicity,
const double tolerance)
: ChartManifold<dim, spacedim, chartdim>(periodicity)
, const_map()
FunctionManifold<dim, spacedim, chartdim>::FunctionManifold(
const std::string push_forward_expression,
const std::string pull_back_expression,
- const Tensor<1, chartdim> & periodicity,
+ const Tensor<1, chartdim> &periodicity,
const typename FunctionParser<spacedim>::ConstMap const_map,
const std::string chart_vars,
const std::string space_vars,
template <typename AccessorType>
Point<AccessorType::space_dimension>
compute_transfinite_interpolation(const AccessorType &cell,
- const Point<1> & chart_point,
+ const Point<1> &chart_point,
const bool /*cell_is_flat*/)
{
return cell.vertex(0) * (1. - chart_point[0]) +
template <typename AccessorType>
Point<AccessorType::space_dimension>
compute_transfinite_interpolation(const AccessorType &cell,
- const Point<2> & chart_point,
+ const Point<2> &chart_point,
const bool cell_is_flat)
{
const unsigned int dim = AccessorType::dimension;
template <typename AccessorType>
Point<AccessorType::space_dimension>
compute_transfinite_interpolation(const AccessorType &cell,
- const Point<3> & chart_point,
+ const Point<3> &chart_point,
const bool cell_is_flat)
{
const unsigned int dim = AccessorType::dimension;
Point<spacedim>
TransfiniteInterpolationManifold<dim, spacedim>::push_forward(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<dim> & chart_point) const
+ const Point<dim> &chart_point) const
{
AssertDimension(cell->level(), level_coarse);
DerivativeForm<1, dim, spacedim>
TransfiniteInterpolationManifold<dim, spacedim>::push_forward_gradient(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<dim> & chart_point,
+ const Point<dim> &chart_point,
const Point<spacedim> &pushed_forward_chart_point) const
{
// compute the derivative with the help of finite differences
Point<dim>
TransfiniteInterpolationManifold<dim, spacedim>::pull_back(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const Point<spacedim> & point,
+ const Point<spacedim> &point,
const Point<dim> &initial_guess) const
{
Point<dim> outside;
Point<spacedim>
TransfiniteInterpolationManifold<dim, spacedim>::get_new_point(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const ArrayView<const double> & weights) const
+ const ArrayView<const double> &weights) const
{
boost::container::small_vector<Point<dim>, 100> chart_points(
surrounding_points.size());
void
TransfiniteInterpolationManifold<dim, spacedim>::get_new_points(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Table<2, double> & weights,
+ const Table<2, double> &weights,
ArrayView<Point<spacedim>> new_points) const
{
Assert(weights.size(0) > 0, ExcEmptyObject());
template <>
std::pair<Point<3>, double>
project_to_quad(const std::array<Point<3>, 3> &vertices,
- const Point<3> & p,
+ const Point<3> &p,
const ReferenceCell face_reference_cell)
{
Assert(face_reference_cell == ReferenceCells::Triangle ||
Mapping<deal_II_dimension, deal_II_space_dimension>>
ReferenceCell::get_default_mapping(const unsigned int degree) const;
- template const Mapping<deal_II_dimension, deal_II_space_dimension>
- &ReferenceCell::get_default_linear_mapping() const;
+ template const Mapping<deal_II_dimension, deal_II_space_dimension> &
+ ReferenceCell::get_default_linear_mapping() const;
#endif
}
template Quadrature<deal_II_dimension>
ReferenceCell::get_gauss_type_quadrature(const unsigned n_points_1D) const;
- template const Quadrature<deal_II_dimension>
- &ReferenceCell::get_nodal_type_quadrature() const;
+ template const Quadrature<deal_II_dimension> &
+ ReferenceCell::get_nodal_type_quadrature() const;
template Point<deal_II_dimension> ReferenceCell::closest_point(
const Point<deal_II_dimension> &) const;
&pack_callbacks_fixed,
const std::vector<
typename internal::CellAttachedData<dim, spacedim>::pack_callback_t>
- & pack_callbacks_variable,
+ &pack_callbacks_variable,
const MPI_Comm &mpi_communicator)
{
Assert(src_data_fixed.empty(),
void CellAttachedDataSerializer<dim, spacedim>::unpack_data(
const std::vector<
typename CellAttachedDataSerializer<dim, spacedim>::cell_relation_t>
- & cell_relations,
+ &cell_relations,
const unsigned int handle,
const std::function<
void(const cell_iterator &,
const unsigned int global_first_cell,
const unsigned int global_num_cells,
const std::string &filename,
- const MPI_Comm & mpi_communicator) const
+ const MPI_Comm &mpi_communicator) const
{
Assert(sizes_fixed_cumulative.size() > 0,
ExcMessage("No data has been packed!"));
const std::string &filename,
const unsigned int n_attached_deserialize_fixed,
const unsigned int n_attached_deserialize_variable,
- const MPI_Comm & mpi_communicator)
+ const MPI_Comm &mpi_communicator)
{
Assert(dest_data_fixed.empty(),
ExcMessage("Previously loaded data has not been released yet!"));
const typename Triangulation<dim, spacedim>::cell_iterator &cell_2,
unsigned int n_face_1,
unsigned int n_face_2,
- const std::bitset<3> & orientation,
+ const std::bitset<3> &orientation,
typename std::map<
std::pair<typename Triangulation<dim, spacedim>::cell_iterator,
unsigned int>,
* @note Used only for dim=3.
*/
void
- reserve_space(TriaFaces & tria_faces,
+ reserve_space(TriaFaces &tria_faces,
const unsigned int new_quads_in_pairs,
const unsigned int new_quads_single)
{
*/
void
- reserve_space(TriaLevel & tria_level,
+ reserve_space(TriaLevel &tria_level,
const unsigned int total_cells,
const unsigned int dimension,
const unsigned int space_dimension)
* should be called from the functions of the higher TriaLevel classes.
*/
void
- monitor_memory(const TriaLevel & tria_level,
+ monitor_memory(const TriaLevel &tria_level,
const unsigned int true_dimension)
{
(void)tria_level;
* lines in the interior of refined cells can be stored as single lines.
*/
void
- reserve_space(TriaObjects & tria_objects,
+ reserve_space(TriaObjects &tria_objects,
const unsigned int new_objects_in_pairs,
const unsigned int new_objects_single = 0)
{
*/
virtual void
delete_children(
- Triangulation<dim, spacedim> & triangulation,
+ Triangulation<dim, spacedim> &triangulation,
typename Triangulation<dim, spacedim>::cell_iterator &cell,
- std::vector<unsigned int> & line_cell_count,
+ std::vector<unsigned int> &line_cell_count,
std::vector<unsigned int> &quad_cell_count) = 0;
/**
void
delete_children(
- Triangulation<dim, spacedim> & tria,
+ Triangulation<dim, spacedim> &tria,
typename Triangulation<dim, spacedim>::cell_iterator &cell,
- std::vector<unsigned int> & line_cell_count,
+ std::vector<unsigned int> &line_cell_count,
std::vector<unsigned int> &quad_cell_count) override
{
T::delete_children(tria, cell, line_cell_count, quad_cell_count);
template <int dim, int spacedim>
static void
compute_number_cache_dim(
- const Triangulation<dim, spacedim> & triangulation,
+ const Triangulation<dim, spacedim> &triangulation,
const unsigned int level_objects,
internal::TriangulationImplementation::NumberCache<1> &number_cache)
{
template <int dim, int spacedim>
static void
compute_number_cache_dim(
- const Triangulation<dim, spacedim> & triangulation,
+ const Triangulation<dim, spacedim> &triangulation,
const unsigned int level_objects,
internal::TriangulationImplementation::NumberCache<2> &number_cache)
{
template <int dim, int spacedim>
static void
compute_number_cache_dim(
- const Triangulation<dim, spacedim> & triangulation,
+ const Triangulation<dim, spacedim> &triangulation,
const unsigned int level_objects,
internal::TriangulationImplementation::NumberCache<3> &number_cache)
{
template <int dim, int spacedim>
static void
compute_number_cache(
- const Triangulation<dim, spacedim> & triangulation,
+ const Triangulation<dim, spacedim> &triangulation,
const unsigned int level_objects,
internal::TriangulationImplementation::NumberCache<dim> &number_cache)
{
template <int dim, int spacedim>
static void
create_triangulation(const std::vector<Point<spacedim>> &vertices,
- const std::vector<CellData<dim>> & cells,
- const SubCellData & subcelldata,
- Triangulation<dim, spacedim> & tria)
+ const std::vector<CellData<dim>> &cells,
+ const SubCellData &subcelldata,
+ Triangulation<dim, spacedim> &tria)
{
AssertThrow(vertices.size() > 0, ExcMessage("No vertices given"));
AssertThrow(cells.size() > 0, ExcMessage("No cells given"));
auto &lines_0 = tria.faces->lines; // data structure to be filled
// get connectivity between quads and lines
- const auto & crs = connectivity.entity_to_entities(1, 0);
+ const auto &crs = connectivity.entity_to_entities(1, 0);
const unsigned int n_lines = crs.ptr.size() - 1;
// allocate memory
auto &faces = *tria.faces;
// get connectivity between quads and lines
- const auto & crs = connectivity.entity_to_entities(2, 1);
+ const auto &crs = connectivity.entity_to_entities(2, 1);
const unsigned int n_quads = crs.ptr.size() - 1;
// allocate memory
template <int structdim, int spacedim, typename T>
static void
process_subcelldata(
- const CRS<T> & crs,
- TriaObjects & obj,
+ const CRS<T> &crs,
+ TriaObjects &obj,
const std::vector<CellData<structdim>> &boundary_objects_in,
- const std::vector<Point<spacedim>> & vertex_locations)
+ const std::vector<Point<spacedim>> &vertex_locations)
{
AssertDimension(obj.structdim, structdim);
static void
- reserve_space_(TriaFaces & faces,
+ reserve_space_(TriaFaces &faces,
const unsigned structdim,
const unsigned int size)
{
static void
- reserve_space_(TriaLevel & level,
+ reserve_space_(TriaLevel &level,
const unsigned int spacedim,
const unsigned int size,
const bool orientation_needed)
static void
create_children(
Triangulation<2, spacedim> &triangulation,
- unsigned int & next_unused_vertex,
+ unsigned int &next_unused_vertex,
typename Triangulation<2, spacedim>::raw_line_iterator
&next_unused_line,
typename Triangulation<2, spacedim>::raw_cell_iterator
typename Triangulation<dim, spacedim>::raw_line_iterator
next_unused_line = triangulation.begin_raw_line();
- const auto create_children = [](auto & triangulation,
+ const auto create_children = [](auto &triangulation,
unsigned int &next_unused_vertex,
- auto & next_unused_line,
- auto & next_unused_cell,
- const auto & cell) {
+ auto &next_unused_line,
+ auto &next_unused_cell,
+ const auto &cell) {
const auto ref_case = cell->refine_flag_set();
cell->clear_refine_flag();
template <int dim, int spacedim>
static void
delete_children(
- Triangulation<dim, spacedim> & triangulation,
+ Triangulation<dim, spacedim> &triangulation,
typename Triangulation<dim, spacedim>::cell_iterator &cell,
- std::vector<unsigned int> & line_cell_count,
- std::vector<unsigned int> & quad_cell_count)
+ std::vector<unsigned int> &line_cell_count,
+ std::vector<unsigned int> &quad_cell_count)
{
AssertThrow(false, ExcNotImplemented());
(void)triangulation;
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
void Triangulation<dim, spacedim>::create_triangulation(
const std::vector<Point<spacedim>> &v,
- const std::vector<CellData<dim>> & cells,
- const SubCellData & subcelldata)
+ const std::vector<CellData<dim>> &cells,
+ const SubCellData &subcelldata)
{
Assert((vertices.empty()) && (levels.empty()) && (faces == nullptr),
ExcTriangulationNotEmpty(vertices.size(), levels.size()));
unsigned int dim,
std::vector<
std::unique_ptr<internal::TriangulationImplementation::TriaLevel>>
- & levels,
+ &levels,
internal::TriangulationImplementation::TriaFaces *faces)
{
if (dim == 1)
unsigned int dim,
std::vector<
std::unique_ptr<internal::TriangulationImplementation::TriaLevel>>
- & levels,
+ &levels,
internal::TriangulationImplementation::TriaFaces *faces)
{
if (dim == 1)
unsigned int Triangulation<dim, spacedim>::register_data_attach(
const std::function<std::vector<char>(const cell_iterator &,
const ::dealii::CellStatus)>
- & pack_callback,
+ &pack_callback,
const bool returns_variable_size_data)
{
unsigned int handle = numbers::invalid_unsigned_int;
const unsigned int magic_number1,
const std::vector<bool> &v,
const unsigned int magic_number2,
- std::ostream & out)
+ std::ostream &out)
{
const unsigned int N = v.size();
- unsigned char * flags = new unsigned char[N / 8 + 1];
+ unsigned char *flags = new unsigned char[N / 8 + 1];
for (unsigned int i = 0; i < N / 8 + 1; ++i)
flags[i] = 0;
const unsigned int magic_number1,
std::vector<bool> &v,
const unsigned int magic_number2,
- std::istream & in)
+ std::istream &in)
{
AssertThrow(in.fail() == false, ExcIO());
in >> N;
v.resize(N);
- unsigned char * flags = new unsigned char[N / 8 + 1];
+ unsigned char *flags = new unsigned char[N / 8 + 1];
unsigned short int tmp;
for (unsigned int i = 0; i < N / 8 + 1; ++i)
{
*/
void
collect(
- const std::vector<unsigned int> & relevant_processes,
+ const std::vector<unsigned int> &relevant_processes,
const std::vector<DescriptionTemp<dim, spacedim>> &description_temp,
const MPI_Comm comm,
const bool vertices_have_unique_ids)
void
mark_cell_and_its_parents(
const TriaIterator<CellAccessor<dim, spacedim>> &cell,
- std::vector<std::vector<bool>> & cell_marked)
+ std::vector<std::vector<bool>> &cell_marked)
{
cell_marked[cell->level()][cell->index()] = true;
if (cell->level() != 0)
const dealii::Triangulation<dim, spacedim> &tria,
const std::function<types::subdomain_id(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- &)> & subdomain_id_function,
+ &)> &subdomain_id_function,
const std::function<types::subdomain_id(
const typename dealii::Triangulation<dim, spacedim>::cell_iterator
- &)> & level_subdomain_id_function,
+ &)> &level_subdomain_id_function,
const MPI_Comm comm,
const TriangulationDescription::Settings settings)
: tria(tria)
// (also taking into account periodicity)
const auto
add_vertices_of_cell_to_vertices_owned_by_locally_owned_cells =
- [this](const auto & cell,
+ [this](const auto &cell,
std::vector<bool> &vertices_owned_by_locally_owned_cells) {
// add local vertices
for (const auto v : cell->vertex_indices())
Description<dim, spacedim>
create_description_from_triangulation_in_groups(
const std::function<void(dealii::Triangulation<dim, spacedim> &)>
- & serial_grid_generator,
+ &serial_grid_generator,
const std::function<void(dealii::Triangulation<dim, spacedim> &,
const MPI_Comm,
const unsigned int)> &serial_grid_partitioner,
template <int dim, int spacedim>
Description<dim, spacedim>
create_description_from_triangulation(
- const Triangulation<dim, spacedim> & tria,
+ const Triangulation<dim, spacedim> &tria,
const LinearAlgebra::distributed::Vector<double> &partition,
const TriangulationDescription::Settings settings)
{
template <int dim, int spacedim>
Description<dim, spacedim>
create_description_from_triangulation(
- const Triangulation<dim, spacedim> & tria,
+ const Triangulation<dim, spacedim> &tria,
const LinearAlgebra::distributed::Vector<double> &partition,
const std::vector<LinearAlgebra::distributed::Vector<double>>
- & partitions_mg,
+ &partitions_mg,
const TriangulationDescription::Settings settings_in)
{
#ifdef DEAL_II_WITH_MPI
create_description_from_triangulation_in_groups(
const std::function<void(
dealii::Triangulation<deal_II_dimension, deal_II_space_dimension>
- &)> & serial_grid_generator,
+ &)> &serial_grid_generator,
const std::function<void(
dealii::Triangulation<deal_II_dimension, deal_II_space_dimension> &,
const MPI_Comm,
const Triangulation<deal_II_dimension, deal_II_space_dimension> &tria,
const LinearAlgebra::distributed::Vector<double> &partition,
const std::vector<LinearAlgebra::distributed::Vector<double>>
- & mg_partitions,
+ &mg_partitions,
const TriangulationDescription::Settings settings);
#endif
\}
const std::set<unsigned int> &fes,
const std::function<std::vector<std::pair<unsigned int, unsigned int>>(
const unsigned int,
- const unsigned int)> & query_identities)
+ const unsigned int)> &query_identities)
{
// Let's deal with the easy cases first. If the set of fe indices is empty
// or has only one entry, then there are no identities:
template <int dim, int q_dim, typename FEValuesType>
FEValuesBase<dim, q_dim, FEValuesType>::FEValuesBase(
const MappingCollection<dim, FEValuesType::space_dimension>
- & mapping_collection,
+ &mapping_collection,
const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
- const QCollection<q_dim> & q_collection,
+ const QCollection<q_dim> &q_collection,
const UpdateFlags update_flags)
: fe_collection(&fe_collection)
, mapping_collection(&mapping_collection)
template <int dim, int q_dim, typename FEValuesType>
FEValuesBase<dim, q_dim, FEValuesType>::FEValuesBase(
const MappingCollection<dim, FEValuesType::space_dimension>
- & mapping_collection,
+ &mapping_collection,
const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
- const std::vector<QCollection<q_dim>> & q_collections,
+ const std::vector<QCollection<q_dim>> &q_collections,
const UpdateFlags update_flags)
: fe_collection(&fe_collection)
, mapping_collection(&mapping_collection)
template <int dim, int q_dim, typename FEValuesType>
FEValuesBase<dim, q_dim, FEValuesType>::FEValuesBase(
const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
- const QCollection<q_dim> & q_collection,
+ const QCollection<q_dim> &q_collection,
const UpdateFlags update_flags)
: FEValuesBase(
dealii::hp::StaticMappingQ1<dim, FEValuesType::space_dimension>::
template <int dim, int q_dim, typename FEValuesType>
FEValuesBase<dim, q_dim, FEValuesType>::FEValuesBase(
const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
- const std::vector<QCollection<q_dim>> & q_collection,
+ const std::vector<QCollection<q_dim>> &q_collection,
const UpdateFlags update_flags)
: FEValuesBase(
dealii::hp::StaticMappingQ1<dim, FEValuesType::space_dimension>::
template <int dim, int spacedim>
FEValues<dim, spacedim>::FEValues(
const MappingCollection<dim, spacedim> &mapping,
- const FECollection<dim, spacedim> & fe_collection,
- const QCollection<dim> & q_collection,
+ const FECollection<dim, spacedim> &fe_collection,
+ const QCollection<dim> &q_collection,
const UpdateFlags update_flags)
: hp::FEValuesBase<dim, dim, dealii::FEValues<dim, spacedim>>(mapping,
fe_collection,
template <int dim, int spacedim>
FEValues<dim, spacedim>::FEValues(
const FECollection<dim, spacedim> &fe_collection,
- const QCollection<dim> & q_collection,
+ const QCollection<dim> &q_collection,
const UpdateFlags update_flags)
: hp::FEValuesBase<dim, dim, dealii::FEValues<dim, spacedim>>(fe_collection,
q_collection,
template <int dim, int spacedim>
FEFaceValues<dim, spacedim>::FEFaceValues(
const hp::MappingCollection<dim, spacedim> &mapping,
- const hp::FECollection<dim, spacedim> & fe_collection,
- const hp::QCollection<dim - 1> & q_collection,
+ const hp::FECollection<dim, spacedim> &fe_collection,
+ const hp::QCollection<dim - 1> &q_collection,
const UpdateFlags update_flags)
: hp::FEValuesBase<dim, dim - 1, dealii::FEFaceValues<dim, spacedim>>(
mapping,
template <int dim, int spacedim>
FEFaceValues<dim, spacedim>::FEFaceValues(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const hp::FECollection<dim, spacedim> & fe_collection,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const hp::FECollection<dim, spacedim> &fe_collection,
const std::vector<hp::QCollection<dim - 1>> &q_collection,
const UpdateFlags update_flags)
: hp::FEValuesBase<dim, dim - 1, dealii::FEFaceValues<dim, spacedim>>(
template <int dim, int spacedim>
FEFaceValues<dim, spacedim>::FEFaceValues(
const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim - 1> & q_collection,
+ const hp::QCollection<dim - 1> &q_collection,
const UpdateFlags update_flags)
: hp::FEValuesBase<dim, dim - 1, dealii::FEFaceValues<dim, spacedim>>(
fe_collection,
template <int dim, int spacedim>
FEFaceValues<dim, spacedim>::FEFaceValues(
- const hp::FECollection<dim, spacedim> & fe_collection,
+ const hp::FECollection<dim, spacedim> &fe_collection,
const std::vector<hp::QCollection<dim - 1>> &q_collection,
const UpdateFlags update_flags)
: hp::FEValuesBase<dim, dim - 1, dealii::FEFaceValues<dim, spacedim>>(
template <bool lda>
void
FEFaceValues<dim, spacedim>::reinit(
- const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> & cell,
+ const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &cell,
const typename Triangulation<dim, spacedim>::face_iterator &face,
const unsigned int q_index,
const unsigned int mapping_index,
template <int dim, int spacedim>
FESubfaceValues<dim, spacedim>::FESubfaceValues(
const hp::MappingCollection<dim, spacedim> &mapping,
- const hp::FECollection<dim, spacedim> & fe_collection,
- const hp::QCollection<dim - 1> & q_collection,
+ const hp::FECollection<dim, spacedim> &fe_collection,
+ const hp::QCollection<dim - 1> &q_collection,
const UpdateFlags update_flags)
: hp::FEValuesBase<dim, dim - 1, dealii::FESubfaceValues<dim, spacedim>>(
mapping,
template <int dim, int spacedim>
FESubfaceValues<dim, spacedim>::FESubfaceValues(
const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim - 1> & q_collection,
+ const hp::QCollection<dim - 1> &q_collection,
const UpdateFlags update_flags)
: hp::FEValuesBase<dim, dim - 1, dealii::FESubfaceValues<dim, spacedim>>(
fe_collection,
template <int dim, int spacedim>
void
p_adaptivity_from_flags(const DoFHandler<dim, spacedim> &dof_handler,
- const std::vector<bool> & p_flags)
+ const std::vector<bool> &p_flags)
{
if (dof_handler.get_fe_collection().size() == 0)
// nothing to do
void
p_adaptivity_from_absolute_threshold(
const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const Number p_refine_threshold,
const Number p_coarsen_threshold,
const ComparisonFunction<std_cxx20::type_identity_t<Number>>
void
p_adaptivity_from_relative_threshold(
const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double p_refine_fraction,
const double p_coarsen_fraction,
const ComparisonFunction<std_cxx20::type_identity_t<Number>>
void
p_adaptivity_fixed_number(
const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & criteria,
+ const Vector<Number> &criteria,
const double p_refine_fraction,
const double p_coarsen_fraction,
const ComparisonFunction<std_cxx20::type_identity_t<Number>>
void
p_adaptivity_from_reference(
const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & criteria,
- const Vector<Number> & references,
+ const Vector<Number> &criteria,
+ const Vector<Number> &references,
const ComparisonFunction<std_cxx20::type_identity_t<Number>>
&compare_refine,
const ComparisonFunction<std_cxx20::type_identity_t<Number>>
template <int dim, typename Number, int spacedim>
void
predict_error(const DoFHandler<dim, spacedim> &dof_handler,
- const Vector<Number> & error_indicators,
- Vector<Number> & predicted_errors,
+ const Vector<Number> &error_indicators,
+ Vector<Number> &predicted_errors,
const double gamma_p,
const double gamma_h,
const double gamma_n)
continue;
}
- const auto & parent = cell->parent();
+ const auto &parent = cell->parent();
const unsigned int n_children = parent->n_children();
unsigned int h_flagged_children = 0, p_flagged_children = 0;
{
template void
set_zero_all(
- const std::vector<types::global_dof_index> & cm,
+ const std::vector<types::global_dof_index> &cm,
LinearAlgebra::distributed::Vector<float, MemorySpace::Default> &vec);
template void
set_zero_all(
- const std::vector<types::global_dof_index> & cm,
+ const std::vector<types::global_dof_index> &cm,
LinearAlgebra::distributed::Vector<double, MemorySpace::Default> &vec);
} // namespace AffineConstraintsImplementation
} // namespace internal
void
BlockSparsityPattern::reinit(
- const BlockIndices & rows,
- const BlockIndices & cols,
+ const BlockIndices &rows,
+ const BlockIndices &cols,
const std::vector<std::vector<unsigned int>> &row_lengths)
{
AssertDimension(row_lengths.size(), cols.size());
template __global__ void
vec_scale<float>(float *, const float a, const size_type);
template __global__ void
- vector_bin_op<float, Binop_Addition>(float * v1,
- const float * v2,
+ vector_bin_op<float, Binop_Addition>(float *v1,
+ const float *v2,
const size_type N);
template __global__ void
- vector_bin_op<float, Binop_Subtraction>(float * v1,
- const float * v2,
+ vector_bin_op<float, Binop_Subtraction>(float *v1,
+ const float *v2,
const size_type N);
template __global__ void
masked_vector_bin_op<float, Binop_Addition>(const unsigned int *mask,
- float * v1,
- const float * v2,
+ float *v1,
+ const float *v2,
const size_type N);
template __global__ void
masked_vector_bin_op<float, Binop_Subtraction>(const unsigned int *mask,
- float * v1,
- const float * v2,
+ float *v1,
+ const float *v2,
const size_type N);
template struct ElemSum<float>;
template struct L1Norm<float>;
template struct LInfty<float>;
template __global__ void
- reduction<float, ElemSum<float>>(float * result,
- const float * v,
+ reduction<float, ElemSum<float>>(float *result,
+ const float *v,
const size_type N);
template __global__ void
- reduction<float, L1Norm<float>>(float * result,
- const float * v,
+ reduction<float, L1Norm<float>>(float *result,
+ const float *v,
const size_type N);
template __global__ void
- reduction<float, LInfty<float>>(float * result,
- const float * v,
+ reduction<float, LInfty<float>>(float *result,
+ const float *v,
const size_type N);
template struct DotProduct<float>;
template __global__ void
- double_vector_reduction<float, DotProduct<float>>(float * result,
- const float * v1,
- const float * v2,
+ double_vector_reduction<float, DotProduct<float>>(float *result,
+ const float *v1,
+ const float *v2,
const size_type N);
template __global__ void
vec_add<float>(float *val, const float, const size_type N);
template __global__ void
- add_aV<float>(float * val,
+ add_aV<float>(float *val,
const float a,
- const float * V_val,
+ const float *V_val,
const size_type N);
template __global__ void
- add_aVbW<float>(float * val,
+ add_aVbW<float>(float *val,
const float a,
- const float * V_val,
+ const float *V_val,
const float b,
- const float * W_val,
+ const float *W_val,
const size_type N);
template __global__ void
sadd<float>(const float s,
- float * val,
+ float *val,
const float a,
- const float * V_val,
+ const float *V_val,
const size_type N);
template __global__ void
sadd<float>(const float s,
- float * val,
+ float *val,
const float a,
- const float * V_val,
+ const float *V_val,
const float b,
- const float * W_val,
+ const float *W_val,
const size_type N);
template __global__ void
scale<float>(float *val, const float *V_val, const size_type N);
template __global__ void
- equ<float>(float * val,
+ equ<float>(float *val,
const float a,
- const float * V_val,
+ const float *V_val,
const size_type N);
template __global__ void
- equ<float>(float * val,
+ equ<float>(float *val,
const float a,
- const float * V_val,
+ const float *V_val,
const float b,
- const float * W_val,
+ const float *W_val,
const size_type N);
template __global__ void
- add_and_dot<float>(float * res,
- float * v1,
- const float * v2,
- const float * v3,
+ add_and_dot<float>(float *res,
+ float *v1,
+ const float *v2,
+ const float *v3,
const float a,
const size_type N);
template __global__ void
set<float>(float *val, const float s, const size_type N);
template __global__ void
set_permutated<float, size_type>(const size_type *indices,
- float * val,
- const float * v,
+ float *val,
+ const float *v,
const size_type N);
template __global__ void
- gather<float, size_type>(float * val,
+ gather<float, size_type>(float *val,
const size_type *indices,
- const float * v,
+ const float *v,
const size_type N);
template __global__ void
add_permutated<float>(const size_type *indices,
- float * val,
- const float * v,
+ float *val,
+ const float *v,
const size_type N);
template __global__ void
vec_scale<double>(double *, const double a, const size_type);
template __global__ void
- vector_bin_op<double, Binop_Addition>(double * v1,
- const double * v2,
+ vector_bin_op<double, Binop_Addition>(double *v1,
+ const double *v2,
const size_type N);
template __global__ void
- vector_bin_op<double, Binop_Subtraction>(double * v1,
- const double * v2,
+ vector_bin_op<double, Binop_Subtraction>(double *v1,
+ const double *v2,
const size_type N);
template __global__ void
masked_vector_bin_op<double, Binop_Addition>(const unsigned int *mask,
- double * v1,
- const double * v2,
+ double *v1,
+ const double *v2,
const size_type N);
template __global__ void
masked_vector_bin_op<double, Binop_Subtraction>(const unsigned int *mask,
- double * v1,
- const double * v2,
+ double *v1,
+ const double *v2,
const size_type N);
template struct ElemSum<double>;
template struct L1Norm<double>;
template struct LInfty<double>;
template __global__ void
- reduction<double, ElemSum<double>>(double * result,
- const double * v,
+ reduction<double, ElemSum<double>>(double *result,
+ const double *v,
const size_type N);
template __global__ void
- reduction<double, L1Norm<double>>(double * result,
- const double * v,
+ reduction<double, L1Norm<double>>(double *result,
+ const double *v,
const size_type N);
template __global__ void
- reduction<double, LInfty<double>>(double * result,
- const double * v,
+ reduction<double, LInfty<double>>(double *result,
+ const double *v,
const size_type N);
template struct DotProduct<double>;
template __global__ void
- double_vector_reduction<double, DotProduct<double>>(double * result,
+ double_vector_reduction<double, DotProduct<double>>(double *result,
const double *v1,
const double *v2,
const size_type N);
template __global__ void
vec_add<double>(double *val, const double, const size_type N);
template __global__ void
- add_aV<double>(double * val,
+ add_aV<double>(double *val,
const double a,
- const double * V_val,
+ const double *V_val,
const size_type N);
template __global__ void
- add_aVbW<double>(double * val,
+ add_aVbW<double>(double *val,
const double a,
- const double * V_val,
+ const double *V_val,
const double b,
- const double * W_val,
+ const double *W_val,
const size_type N);
template __global__ void
sadd<double>(const double s,
- double * val,
+ double *val,
const double a,
- const double * V_val,
+ const double *V_val,
const size_type N);
template __global__ void
sadd<double>(const double s,
- double * val,
+ double *val,
const double a,
- const double * V_val,
+ const double *V_val,
const double b,
- const double * W_val,
+ const double *W_val,
const size_type N);
template __global__ void
scale<double>(double *val, const double *V_val, const size_type N);
template __global__ void
- equ<double>(double * val,
+ equ<double>(double *val,
const double a,
- const double * V_val,
+ const double *V_val,
const size_type N);
template __global__ void
- equ<double>(double * val,
+ equ<double>(double *val,
const double a,
- const double * V_val,
+ const double *V_val,
const double b,
- const double * W_val,
+ const double *W_val,
const size_type N);
template __global__ void
- add_and_dot<double>(double * res,
- double * v1,
- const double * v2,
- const double * v3,
+ add_and_dot<double>(double *res,
+ double *v1,
+ const double *v2,
+ const double *v3,
const double a,
const size_type N);
template __global__ void
set<double>(double *val, const double s, const size_type N);
template __global__ void
set_permutated<double, size_type>(const size_type *indices,
- double * val,
- const double * v,
+ double *val,
+ const double *v,
const size_type N);
template __global__ void
- gather<double, size_type>(double * val,
+ gather<double, size_type>(double *val,
const size_type *indices,
- const double * v,
+ const double *v,
const size_type N);
template __global__ void
add_permutated<double>(const size_type *indices,
- double * val,
- const double * v,
+ double *val,
+ const double *v,
const size_type N);
} // namespace kernel
} // namespace CUDAWrappers
int m,
int nnz,
const cusparseMatDescr_t descrA,
- float * csrValA_valM,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ float *csrValA_valM,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseScsrilu02(handle,
m,
int m,
int nnz,
const cusparseMatDescr_t descrA,
- double * csrValA_valM,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ double *csrValA_valM,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseDcsrilu02(handle,
m,
int m,
int nnz,
const cusparseMatDescr_t descrA,
- const float * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ const float *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseScsrilu02_analysis(handle,
m,
int m,
int nnz,
const cusparseMatDescr_t descrA,
- const double * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ const double *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseDcsrilu02_analysis(handle,
m,
int m,
int nnz,
const cusparseMatDescr_t descrA,
- float * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ float *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrilu02Info_t info,
int *pBufferSizeInBytes)
{
int m,
int nnz,
const cusparseMatDescr_t descrA,
- double * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ double *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrilu02Info_t info,
int *pBufferSizeInBytes)
{
int m,
int nnz,
const cusparseMatDescr_t descrA,
- float * csrValA_valM,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ float *csrValA_valM,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseScsric02(handle,
m,
int m,
int nnz,
const cusparseMatDescr_t descrA,
- double * csrValA_valM,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ double *csrValA_valM,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseDcsric02(handle,
m,
cusparseOperation_t transA,
int m,
int nnz,
- const float * alpha,
+ const float *alpha,
const cusparseMatDescr_t descra,
- const float * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ const float *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrsv2Info_t info,
- const float * x,
- float * y,
+ const float *x,
+ float *y,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseScsrsv2_solve(handle,
transA,
cusparseOperation_t transA,
int m,
int nnz,
- const double * alpha,
+ const double *alpha,
const cusparseMatDescr_t descra,
- const double * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ const double *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrsv2Info_t info,
- const double * x,
- double * y,
+ const double *x,
+ double *y,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseDcsrsv2_solve(handle,
transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
- const float * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ const float *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrsv2Info_t info,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseScsrsv2_analysis(handle,
transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
- const double * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ const double *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrsv2Info_t info,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseDcsrsv2_analysis(handle,
transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
- const float * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ const float *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseScsric02_analysis(handle,
m,
int m,
int nnz,
const cusparseMatDescr_t descrA,
- const double * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ const double *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
- void * pBuffer)
+ void *pBuffer)
{
return cusparseDcsric02_analysis(handle,
m,
int m,
int nnz,
const cusparseMatDescr_t descrA,
- float * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ float *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrsv2Info_t info,
- int * pBufferSizeInBytes)
+ int *pBufferSizeInBytes)
{
return cusparseScsrsv2_bufferSize(handle,
transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
- double * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ double *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csrsv2Info_t info,
int *pBufferSizeInBytes)
{
int m,
int nnz,
const cusparseMatDescr_t descrA,
- float * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ float *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csric02Info_t info,
int *pBufferSizeInBytes)
{
int m,
int nnz,
const cusparseMatDescr_t descrA,
- double * csrValA,
- const int * csrRowPtrA,
- const int * csrColIndA,
+ double *csrValA,
+ const int *csrRowPtrA,
+ const int *csrColIndA,
csric02Info_t info,
int *pBufferSizeInBytes)
{
template <typename Number>
void
PreconditionIC<Number>::vmult(
- LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const
{
Assert(P_val_dev != nullptr, ExcNotInitialized());
template <typename Number>
void
PreconditionIC<Number>::Tvmult(
- LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const
{
// the constructed preconditioner is symmetric
template <typename Number>
void
PreconditionILU<Number>::vmult(
- LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const
{
Assert(P_val_dev != nullptr, ExcNotInitialized());
void
cusparsecsr2dense(cusparseHandle_t cusparse_handle,
const SparseMatrix<float> &matrix,
- float * dense_matrix_dev)
+ float *dense_matrix_dev)
{
auto cusparse_matrix = matrix.get_cusparse_matrix();
void
cusparsecsr2dense(cusparseHandle_t cusparse_handle,
const SparseMatrix<double> &matrix,
- double * dense_matrix_dev)
+ double *dense_matrix_dev)
{
auto cusparse_matrix = matrix.get_cusparse_matrix();
cusolverDngetrf_buffer_size(cusolverDnHandle_t cusolver_dn_handle,
int m,
int n,
- float * dense_matrix_dev,
- int & workspace_size)
+ float *dense_matrix_dev,
+ int &workspace_size)
{
const cusolverStatus_t cusolver_error_code = cusolverDnSgetrf_bufferSize(
cusolver_dn_handle, m, n, dense_matrix_dev, m, &workspace_size);
cusolverDngetrf_buffer_size(cusolverDnHandle_t cusolver_dn_handle,
int m,
int n,
- double * dense_matrix_dev,
- int & workspace_size)
+ double *dense_matrix_dev,
+ int &workspace_size)
{
const cusolverStatus_t cusolver_error_code = cusolverDnDgetrf_bufferSize(
cusolver_dn_handle, m, n, dense_matrix_dev, m, &workspace_size);
cusolverDngetrf(cusolverDnHandle_t cusolver_dn_handle,
int m,
int n,
- float * dense_matrix_dev,
- float * workspace_dev,
- int * pivot_dev,
- int * info_dev)
+ float *dense_matrix_dev,
+ float *workspace_dev,
+ int *pivot_dev,
+ int *info_dev)
{
const cusolverStatus_t cusolver_error_code =
cusolverDnSgetrf(cusolver_dn_handle,
cusolverDngetrf(cusolverDnHandle_t cusolver_dn_handle,
int m,
int n,
- double * dense_matrix_dev,
- double * workspace_dev,
- int * pivot_dev,
- int * info_dev)
+ double *dense_matrix_dev,
+ double *workspace_dev,
+ int *pivot_dev,
+ int *info_dev)
{
const cusolverStatus_t cusolver_error_code =
cusolverDnDgetrf(cusolver_dn_handle,
void
cusolverDngetrs(cusolverDnHandle_t cusolver_dn_handle,
int m,
- float * dense_matrix_dev,
- int * pivot_dev,
- float * b,
- int * info_dev)
+ float *dense_matrix_dev,
+ int *pivot_dev,
+ float *b,
+ int *info_dev)
{
const int n_rhs = 1;
const cusolverStatus_t cusolver_error_code =
void
cusolverDngetrs(cusolverDnHandle_t cusolver_dn_handle,
int m,
- double * dense_matrix_dev,
- int * pivot_dev,
- double * b,
- int * info_dev)
+ double *dense_matrix_dev,
+ int *pivot_dev,
+ double *b,
+ int *info_dev)
{
const int n_rhs = 1;
const cusolverStatus_t cusolver_error_code =
const unsigned int n_rows,
const unsigned int nnz,
cusparseMatDescr_t descr,
- const float * val_host,
- const int * row_ptr_host,
- const int * column_index_host,
- const float * b_host,
- float * x_host)
+ const float *val_host,
+ const int *row_ptr_host,
+ const int *column_index_host,
+ const float *b_host,
+ float *x_host)
{
int singularity = 0;
const cusolverStatus_t cusolver_error_code =
const unsigned int n_rows,
unsigned int nnz,
cusparseMatDescr_t descr,
- const double * val_host,
- const int * row_ptr_host,
- const int * column_index_host,
- const double * b_host,
- double * x_host)
+ const double *val_host,
+ const int *row_ptr_host,
+ const int *column_index_host,
+ const double *b_host,
+ double *x_host)
{
int singularity = 0;
const cusolverStatus_t cusolver_error_code =
void
cholesky_factorization(cusolverSpHandle_t cusolver_sp_handle,
const SparseMatrix<float> &matrix,
- const float * b,
- float * x)
+ const float *b,
+ float *x)
{
auto cusparse_matrix = matrix.get_cusparse_matrix();
int singularity = 0;
void
cholesky_factorization(cusolverSpHandle_t cusolver_sp_handle,
const SparseMatrix<double> &matrix,
- const double * b,
- double * x)
+ const double *b,
+ double *x)
{
auto cusparse_matrix = matrix.get_cusparse_matrix();
int singularity = 0;
lu_factorization(cusparseHandle_t cusparse_handle,
cusolverDnHandle_t cusolver_dn_handle,
const SparseMatrix<Number> &matrix,
- const Number * b_dev,
- Number * x_dev)
+ const Number *b_dev,
+ Number *x_dev)
{
// Change the format of the matrix from sparse to dense
const unsigned int m = matrix.m();
void
lu_factorization(cusolverSpHandle_t cusolver_sp_handle,
const SparseMatrix<Number> &matrix,
- const Number * b_dev,
- Number * x_dev)
+ const Number *b_dev,
+ Number *x_dev)
{
// cuSOLVER does not support LU factorization of sparse matrix on the
// device, so we need to move everything to the host first and then back
template <typename Number>
SolverDirect<Number>::SolverDirect(const Utilities::CUDA::Handle &handle,
- SolverControl & cn,
- const AdditionalData & data)
+ SolverControl &cn,
+ const AdditionalData &data)
: cuda_handle(handle)
, solver_control(cn)
, additional_data(data.solver_type)
template <typename Number>
void
SolverDirect<Number>::solve(
- const SparseMatrix<Number> & A,
- LinearAlgebra::CUDAWrappers::Vector<Number> & x,
+ const SparseMatrix<Number> &A,
+ LinearAlgebra::CUDAWrappers::Vector<Number> &x,
const LinearAlgebra::CUDAWrappers::Vector<Number> &b)
{
if (additional_data.solver_type == "Cholesky")
{
template <typename Number>
__global__ void
- scale(Number * val,
+ scale(Number *val,
const Number a,
const typename SparseMatrix<Number>::size_type N)
{
create_sp_mat_descr(int m,
int n,
int nnz,
- const float * A_val_dev,
- const int * A_row_ptr_dev,
- const int * A_column_index_dev,
+ const float *A_val_dev,
+ const int *A_row_ptr_dev,
+ const int *A_column_index_dev,
cusparseSpMatDescr_t &sp_descr)
{
cusparseStatus_t error_code = cusparseCreateCsr(
create_sp_mat_descr(int m,
int n,
int nnz,
- const double * A_val_dev,
- const int * A_row_ptr_dev,
- const int * A_column_index_dev,
+ const double *A_val_dev,
+ const int *A_row_ptr_dev,
+ const int *A_column_index_dev,
cusparseSpMatDescr_t &sp_descr)
{
cusparseStatus_t error_code = cusparseCreateCsr(
int m,
int n,
const cusparseSpMatDescr_t sp_descr,
- const float * x,
+ const float *x,
bool add,
- float * y)
+ float *y)
{
float alpha = 1.;
float beta = add ? 1. : 0.;
CUSPARSE_MV_ALG_DEFAULT,
&buffer_size);
- void * buffer = nullptr;
+ void *buffer = nullptr;
cudaError_t cuda_error_code = cudaMalloc(&buffer, buffer_size);
AssertCuda(cuda_error_code);
int m,
int n,
const cusparseSpMatDescr_t sp_descr,
- const double * x,
+ const double *x,
bool add,
- double * y)
+ double *y)
{
double alpha = 1.;
double beta = add ? 1. : 0.;
CUSPARSE_MV_ALG_DEFAULT,
&buffer_size);
- void * buffer = nullptr;
+ void *buffer = nullptr;
cudaError_t cuda_error_code = cudaMalloc(&buffer, buffer_size);
AssertCuda(cuda_error_code);
template <typename Number>
__global__ void
l1_norm(const typename SparseMatrix<Number>::size_type n_rows,
- const Number * val_dev,
- const int * column_index_dev,
- const int * row_ptr_dev,
- Number * sums)
+ const Number *val_dev,
+ const int *column_index_dev,
+ const int *row_ptr_dev,
+ Number *sums)
{
const typename SparseMatrix<Number>::size_type row =
threadIdx.x + blockIdx.x * blockDim.x;
template <typename Number>
__global__ void
linfty_norm(const typename SparseMatrix<Number>::size_type n_rows,
- const Number * val_dev,
+ const Number *val_dev,
const int * /*column_index_dev*/,
const int *row_ptr_dev,
- Number * sums)
+ Number *sums)
{
const typename SparseMatrix<Number>::size_type row =
threadIdx.x + blockIdx.x * blockDim.x;
template <typename Number>
SparseMatrix<Number>::SparseMatrix(
- Utilities::CUDA::Handle & handle,
+ Utilities::CUDA::Handle &handle,
const ::dealii::SparseMatrix<Number> &sparse_matrix_host)
: val_dev(nullptr, Utilities::CUDA::delete_device_data<Number>)
, column_index_dev(nullptr, Utilities::CUDA::delete_device_data<int>)
template <typename Number>
void
SparseMatrix<Number>::reinit(
- Utilities::CUDA::Handle & handle,
+ Utilities::CUDA::Handle &handle,
const ::dealii::SparseMatrix<Number> &sparse_matrix_host)
{
cusparse_handle = handle.cusparse_handle;
template <typename Number>
void
SparseMatrix<Number>::vmult(
- LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const
{
internal::csrmv(cusparse_handle,
template <typename Number>
void
SparseMatrix<Number>::Tvmult(
- LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const
{
internal::csrmv(cusparse_handle,
template <typename Number>
void
SparseMatrix<Number>::vmult_add(
- LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const
{
internal::csrmv(cusparse_handle,
template <typename Number>
void
SparseMatrix<Number>::Tvmult_add(
- LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const
{
internal::csrmv(cusparse_handle,
template <typename Number>
Number
SparseMatrix<Number>::residual(
- LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
+ LinearAlgebra::CUDAWrappers::Vector<Number> &dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &x,
const LinearAlgebra::CUDAWrappers::Vector<Number> &b) const
{
else if (operation == VectorOperation::add)
{
// Create a temporary vector on the device
- Number * tmp;
+ Number *tmp;
cudaError_t error_code =
cudaMalloc(&tmp, n_elements * sizeof(Number));
AssertCuda(error_code);
ExcMessage(
"Cannot add two vectors with different numbers of elements"));
- Number * result_device;
+ Number *result_device;
cudaError_t error_code =
cudaMalloc(&result_device, n_elements * sizeof(Number));
AssertCuda(error_code);
typename Vector<Number>::value_type
Vector<Number>::mean_value() const
{
- Number * result_device;
+ Number *result_device;
cudaError_t error_code = cudaMalloc(&result_device, sizeof(Number));
AssertCuda(error_code);
error_code = cudaMemset(result_device, 0, sizeof(Number));
typename Vector<Number>::real_type
Vector<Number>::l1_norm() const
{
- Number * result_device;
+ Number *result_device;
cudaError_t error_code = cudaMalloc(&result_device, sizeof(Number));
AssertCuda(error_code);
error_code = cudaMemset(result_device, 0, sizeof(Number));
typename Vector<Number>::real_type
Vector<Number>::linfty_norm() const
{
- Number * result_device;
+ Number *result_device;
cudaError_t error_code = cudaMalloc(&result_device, sizeof(Number));
AssertCuda(error_code);
error_code = cudaMemset(result_device, 0, sizeof(Number));
Assert(W.size() == this->size(),
ExcMessage("Vector W has the wrong size."));
- Number * result_device;
+ Number *result_device;
cudaError_t error_code = cudaMalloc(&result_device, sizeof(Number));
AssertCuda(error_code);
error_code = cudaMemset(result_device, 0, sizeof(Number));
template <typename Number>
void
- Vector<Number>::print(std::ostream & out,
+ Vector<Number>::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool) const
void
DynamicSparsityPattern::add_row_entries(
- const size_type & row,
+ const size_type &row,
const ArrayView<const size_type> &columns,
const bool indices_are_sorted)
{
template <typename SparsityPatternTypeLeft, typename SparsityPatternTypeRight>
void
DynamicSparsityPattern::compute_Tmmult_pattern(
- const SparsityPatternTypeLeft & sp_A,
+ const SparsityPatternTypeLeft &sp_A,
const SparsityPatternTypeRight &sp_B)
{
Assert(sp_A.n_rows() == sp_B.n_rows(),
new_cols.resize(sp_B.row_length(i));
{
const auto last_il = sp_B.end(i);
- auto * col_ptr = new_cols.data();
+ auto *col_ptr = new_cols.data();
for (auto il = sp_B.begin(i); il != last_il; ++il)
*col_ptr++ = il->column();
}
template <typename SparsityPatternTypeLeft, typename SparsityPatternTypeRight>
void
DynamicSparsityPattern::compute_mmult_pattern(
- const SparsityPatternTypeLeft & left,
+ const SparsityPatternTypeLeft &left,
const SparsityPatternTypeRight &right)
{
Assert(left.n_cols() == right.n_rows(),
#ifdef DEAL_II_WITH_PETSC
// PetscErrorMessage changes the value in a pointer to refer to a
// statically allocated description of the current error message.
- const char * petsc_message;
+ const char *petsc_message;
const PetscErrorCode ierr =
PetscErrorMessage(static_cast<PetscErrorCode>(error_code),
&petsc_message,
template <typename ValueType, typename IndexType>
void
- SolverBase<ValueType, IndexType>::apply(Vector<ValueType> & solution,
+ SolverBase<ValueType, IndexType>::apply(Vector<ValueType> &solution,
const Vector<ValueType> &rhs)
{
// some shortcuts.
template <typename ValueType, typename IndexType>
void
SolverBase<ValueType, IndexType>::solve(const SparseMatrix<ValueType> &matrix,
- Vector<ValueType> & solution,
+ Vector<ValueType> &solution,
const Vector<ValueType> &rhs)
{
initialize(matrix);
/* ---------------------- SolverCG ------------------------ */
template <typename ValueType, typename IndexType>
- SolverCG<ValueType, IndexType>::SolverCG(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverCG<ValueType, IndexType>::SolverCG(SolverControl &solver_control,
+ const std::string &exec_type,
const AdditionalData &data)
: SolverBase<ValueType, IndexType>(solver_control, exec_type)
, additional_data(data)
template <typename ValueType, typename IndexType>
SolverCG<ValueType, IndexType>::SolverCG(
- SolverControl & solver_control,
- const std::string & exec_type,
+ SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &preconditioner,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<ValueType, IndexType>(solver_control, exec_type)
, additional_data(data)
{
/* ---------------------- SolverBicgstab ------------------------ */
template <typename ValueType, typename IndexType>
SolverBicgstab<ValueType, IndexType>::SolverBicgstab(
- SolverControl & solver_control,
- const std::string & exec_type,
+ SolverControl &solver_control,
+ const std::string &exec_type,
const AdditionalData &data)
: SolverBase<ValueType, IndexType>(solver_control, exec_type)
, additional_data(data)
template <typename ValueType, typename IndexType>
SolverBicgstab<ValueType, IndexType>::SolverBicgstab(
- SolverControl & solver_control,
- const std::string & exec_type,
+ SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &preconditioner,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<ValueType, IndexType>(solver_control, exec_type)
, additional_data(data)
{
/* ---------------------- SolverCGS ------------------------ */
template <typename ValueType, typename IndexType>
- SolverCGS<ValueType, IndexType>::SolverCGS(SolverControl & solver_control,
+ SolverCGS<ValueType, IndexType>::SolverCGS(SolverControl &solver_control,
const std::string &exec_type,
const AdditionalData &data)
: SolverBase<ValueType, IndexType>(solver_control, exec_type)
template <typename ValueType, typename IndexType>
SolverCGS<ValueType, IndexType>::SolverCGS(
- SolverControl & solver_control,
- const std::string & exec_type,
+ SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &preconditioner,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<ValueType, IndexType>(solver_control, exec_type)
, additional_data(data)
{
/* ---------------------- SolverFCG ------------------------ */
template <typename ValueType, typename IndexType>
- SolverFCG<ValueType, IndexType>::SolverFCG(SolverControl & solver_control,
+ SolverFCG<ValueType, IndexType>::SolverFCG(SolverControl &solver_control,
const std::string &exec_type,
const AdditionalData &data)
: SolverBase<ValueType, IndexType>(solver_control, exec_type)
template <typename ValueType, typename IndexType>
SolverFCG<ValueType, IndexType>::SolverFCG(
- SolverControl & solver_control,
- const std::string & exec_type,
+ SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &preconditioner,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<ValueType, IndexType>(solver_control, exec_type)
, additional_data(data)
{
template <typename ValueType, typename IndexType>
SolverGMRES<ValueType, IndexType>::SolverGMRES(
- SolverControl & solver_control,
- const std::string & exec_type,
+ SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &preconditioner,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<ValueType, IndexType>(solver_control, exec_type)
, additional_data(data)
{
/* ---------------------- SolverIR ------------------------ */
template <typename ValueType, typename IndexType>
- SolverIR<ValueType, IndexType>::SolverIR(SolverControl & solver_control,
- const std::string & exec_type,
+ SolverIR<ValueType, IndexType>::SolverIR(SolverControl &solver_control,
+ const std::string &exec_type,
const AdditionalData &data)
: SolverBase<ValueType, IndexType>(solver_control, exec_type)
, additional_data(data)
template <typename ValueType, typename IndexType>
SolverIR<ValueType, IndexType>::SolverIR(
- SolverControl & solver_control,
- const std::string & exec_type,
+ SolverControl &solver_control,
+ const std::string &exec_type,
const std::shared_ptr<gko::LinOpFactory> &inner_solver,
- const AdditionalData & data)
+ const AdditionalData &data)
: SolverBase<ValueType, IndexType>(solver_control, exec_type)
, additional_data(data)
{
{
namespace distributed
{
-#define TEMPL_COPY_CONSTRUCTOR(S1, S2) \
- template Vector<S1, ::dealii::MemorySpace::Host> \
- &Vector<S1, ::dealii::MemorySpace::Host>::operator= \
- <S2>(const Vector<S2, ::dealii::MemorySpace::Host> &)
+#define TEMPL_COPY_CONSTRUCTOR(S1, S2) \
+ template Vector<S1, ::dealii::MemorySpace::Host> & \
+ Vector<S1, ::dealii::MemorySpace::Host>::operator= \
+ <S2>(const Vector<S2, ::dealii::MemorySpace::Host> &)
TEMPL_COPY_CONSTRUCTOR(double, float);
TEMPL_COPY_CONSTRUCTOR(float, double);
void
geev_helper(const char vl,
const char vr,
- AlignedVector<T> & matrix,
+ AlignedVector<T> &matrix,
const types::blas_int n_rows,
- std::vector<T> & real_part_eigenvalues,
- std::vector<T> & imag_part_eigenvalues,
- std::vector<T> & left_eigenvectors,
- std::vector<T> & right_eigenvectors,
- std::vector<T> & real_work,
+ std::vector<T> &real_part_eigenvalues,
+ std::vector<T> &imag_part_eigenvalues,
+ std::vector<T> &left_eigenvectors,
+ std::vector<T> &right_eigenvectors,
+ std::vector<T> &real_work,
std::vector<T> & /*complex_work*/,
const types::blas_int work_flag,
- types::blas_int & info)
+ types::blas_int &info)
{
static_assert(std::is_same_v<T, double> || std::is_same_v<T, float>,
"Only implemented for double and float");
std::vector<std::complex<T>> &left_eigenvectors,
std::vector<std::complex<T>> &right_eigenvectors,
std::vector<std::complex<T>> &complex_work,
- std::vector<T> & real_work,
+ std::vector<T> &real_work,
const types::blas_int work_flag,
- types::blas_int & info)
+ types::blas_int &info)
{
static_assert(
std::is_same_v<T, double> || std::is_same_v<T, float>,
gesdd_helper(const char job,
const types::blas_int n_rows,
const types::blas_int n_cols,
- AlignedVector<T> & matrix,
- std::vector<T> & singular_values,
- AlignedVector<T> & left_vectors,
- AlignedVector<T> & right_vectors,
- std::vector<T> & real_work,
+ AlignedVector<T> &matrix,
+ std::vector<T> &singular_values,
+ AlignedVector<T> &left_vectors,
+ AlignedVector<T> &right_vectors,
+ std::vector<T> &real_work,
std::vector<T> & /*complex work*/,
std::vector<types::blas_int> &integer_work,
const types::blas_int work_flag,
- types::blas_int & info)
+ types::blas_int &info)
{
Assert(job == 'A' || job == 'S' || job == 'O' || job == 'N',
ExcInternalError());
const types::blas_int n_rows,
const types::blas_int n_cols,
AlignedVector<std::complex<T>> &matrix,
- std::vector<T> & singular_values,
+ std::vector<T> &singular_values,
AlignedVector<std::complex<T>> &left_vectors,
AlignedVector<std::complex<T>> &right_vectors,
- std::vector<std::complex<T>> & work,
- std::vector<T> & real_work,
- std::vector<types::blas_int> & integer_work,
- const types::blas_int & work_flag,
- types::blas_int & info)
+ std::vector<std::complex<T>> &work,
+ std::vector<T> &real_work,
+ std::vector<types::blas_int> &integer_work,
+ const types::blas_int &work_flag,
+ types::blas_int &info)
{
Assert(job == 'A' || job == 'S' || job == 'O' || job == 'N',
ExcInternalError());
LAPACKFullMatrix<number>::operator=(const LAPACKFullMatrix<number> &M)
{
TransposeTable<number>::operator=(M);
- state = M.state;
- property = M.property;
+ state = M.state;
+ property = M.property;
return *this;
}
types::blas_int info = 0;
// kl and ku will not be referenced for type = G (dense matrices).
const types::blas_int kl = 0;
- number * values = this->values.data();
+ number *values = this->values.data();
lascl(&type, &kl, &kl, &cfrom, &factor, &m, &n, values, &lda, &info);
types::blas_int info = 0;
// kl and ku will not be referenced for type = G (dense matrices).
const types::blas_int kl = 0;
- number * values = this->values.data();
+ number *values = this->values.data();
lascl(&type, &kl, &kl, &factor, &cto, &m, &n, values, &lda, &info);
// ==> use BLAS 1 for adding vectors
const types::blas_int n = this->m() * this->n();
const types::blas_int inc = 1;
- number * values = this->values.data();
- const number * values_A = A.values.data();
+ number *values = this->values.data();
+ const number *values_A = A.values.data();
axpy(&n, &a, values_A, &inc, values, &inc);
}
void
cholesky_rank1(LAPACKFullMatrix<number> &A,
const number a,
- const Vector<number> & v)
+ const Vector<number> &v)
{
const typename LAPACKFullMatrix<number>::size_type N = A.n();
Vector<number> z(v);
template <typename number>
void
-LAPACKFullMatrix<number>::vmult(Vector<number> & w,
+LAPACKFullMatrix<number>::vmult(Vector<number> &w,
const Vector<number> &v,
const bool adding) const
{
template <typename number>
void
-LAPACKFullMatrix<number>::Tvmult(Vector<number> & w,
+LAPACKFullMatrix<number>::Tvmult(Vector<number> &w,
const Vector<number> &v,
const bool adding) const
{
template <typename number>
void
-LAPACKFullMatrix<number>::vmult_add(Vector<number> & w,
+LAPACKFullMatrix<number>::vmult_add(Vector<number> &w,
const Vector<number> &v) const
{
vmult(w, v, true);
template <typename number>
void
-LAPACKFullMatrix<number>::Tvmult_add(Vector<number> & w,
+LAPACKFullMatrix<number>::Tvmult_add(Vector<number> &w,
const Vector<number> &v) const
{
Tvmult(w, v, true);
template <typename number>
void
-LAPACKFullMatrix<number>::mmult(LAPACKFullMatrix<number> & C,
+LAPACKFullMatrix<number>::mmult(LAPACKFullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding) const
{
template <typename number>
void
-LAPACKFullMatrix<number>::mmult(FullMatrix<number> & C,
+LAPACKFullMatrix<number>::mmult(FullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding) const
{
template <typename number>
void
-LAPACKFullMatrix<number>::Tmmult(LAPACKFullMatrix<number> & C,
+LAPACKFullMatrix<number>::Tmmult(LAPACKFullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
- const Vector<number> & V,
+ const Vector<number> &V,
const bool adding) const
{
Assert(state == matrix || state == inverse_matrix, ExcState(state));
template <typename number>
void
-LAPACKFullMatrix<number>::Tmmult(LAPACKFullMatrix<number> & C,
+LAPACKFullMatrix<number>::Tmmult(LAPACKFullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding) const
{
template <typename number>
void
-LAPACKFullMatrix<number>::Tmmult(FullMatrix<number> & C,
+LAPACKFullMatrix<number>::Tmmult(FullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding) const
{
template <typename number>
void
-LAPACKFullMatrix<number>::mTmult(LAPACKFullMatrix<number> & C,
+LAPACKFullMatrix<number>::mTmult(LAPACKFullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding) const
{
template <typename number>
void
-LAPACKFullMatrix<number>::mTmult(FullMatrix<number> & C,
+LAPACKFullMatrix<number>::mTmult(FullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding) const
{
template <typename number>
void
-LAPACKFullMatrix<number>::TmTmult(LAPACKFullMatrix<number> & C,
+LAPACKFullMatrix<number>::TmTmult(LAPACKFullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding) const
{
template <typename number>
void
-LAPACKFullMatrix<number>::TmTmult(FullMatrix<number> & C,
+LAPACKFullMatrix<number>::TmTmult(FullMatrix<number> &C,
const LAPACKFullMatrix<number> &B,
const bool adding) const
{
number rcond = 0.;
const types::blas_int N = this->m();
- const number * values = this->values.data();
+ const number *values = this->values.data();
types::blas_int info = 0;
const types::blas_int lda = std::max<types::blas_int>(1, N);
work.resize(3 * N);
{
Assert(this->m() == this->n(), LACExceptions::ExcNotQuadratic());
AssertDimension(this->m(), v.size());
- const char * trans = transposed ? &T : &N;
+ const char *trans = transposed ? &T : &N;
const types::blas_int nn = this->n();
const number *const values = this->values.data();
const types::blas_int n_rhs = 1;
Assert(this->m() == this->n(), LACExceptions::ExcNotQuadratic());
AssertDimension(this->m(), B.m());
- const char * trans = transposed ? &T : &N;
+ const char *trans = transposed ? &T : &N;
const types::blas_int nn = this->n();
const number *const values = this->values.data();
const types::blas_int n_rhs = B.n();
template <typename RealNumber>
void
unpack_lapack_eigenvector_and_increment_index(
- const std::vector<RealNumber> & vr,
- const std::complex<RealNumber> & eigenvalue,
+ const std::vector<RealNumber> &vr,
+ const std::complex<RealNumber> &eigenvalue,
FullMatrix<std::complex<RealNumber>> &result,
- unsigned int & index)
+ unsigned int &index)
{
const std::size_t n = result.n();
if (eigenvalue.imag() != 0.)
const std::vector<ComplexNumber> &vr,
const ComplexNumber &,
FullMatrix<ComplexNumber> &result,
- unsigned int & index)
+ unsigned int &index)
{
const std::size_t n = result.n();
for (unsigned int j = 0; j < n; ++j)
const number lower_bound,
const number upper_bound,
const number abs_accuracy,
- Vector<number> & eigenvalues,
+ Vector<number> &eigenvalues,
FullMatrix<number> &eigenvectors)
{
Assert(state == matrix, ExcState(state));
template <typename number>
void
LAPACKFullMatrix<number>::compute_generalized_eigenvalues_symmetric(
- LAPACKFullMatrix<number> & B,
+ LAPACKFullMatrix<number> &B,
const number lower_bound,
const number upper_bound,
const number abs_accuracy,
- Vector<number> & eigenvalues,
+ Vector<number> &eigenvalues,
std::vector<Vector<number>> &eigenvectors,
const types::blas_int itype)
{
template <typename number>
void
LAPACKFullMatrix<number>::compute_generalized_eigenvalues_symmetric(
- LAPACKFullMatrix<number> & B,
+ LAPACKFullMatrix<number> &B,
std::vector<Vector<number>> &eigenvectors,
const types::blas_int itype)
{
template <typename number>
void
-LAPACKFullMatrix<number>::print_formatted(std::ostream & out,
+LAPACKFullMatrix<number>::print_formatted(std::ostream &out,
const unsigned int precision,
const bool scientific,
const unsigned int width_,
- const char * zero_string,
+ const char *zero_string,
const double denominator,
const double threshold) const
{
template <typename number>
void
PreconditionLU<number>::initialize(const LAPACKFullMatrix<number> &M,
- VectorMemory<Vector<number>> & V)
+ VectorMemory<Vector<number>> &V)
{
matrix = &M;
mem = &V;
template <typename number>
void
-PreconditionLU<number>::vmult(Vector<number> & dst,
+PreconditionLU<number>::vmult(Vector<number> &dst,
const Vector<number> &src) const
{
dst = src;
template <typename number>
void
-PreconditionLU<number>::Tvmult(Vector<number> & dst,
+PreconditionLU<number>::Tvmult(Vector<number> &dst,
const Vector<number> &src) const
{
dst = src;
template <typename number>
void
-PreconditionLU<number>::vmult(BlockVector<number> & dst,
+PreconditionLU<number>::vmult(BlockVector<number> &dst,
const BlockVector<number> &src) const
{
Assert(mem != nullptr, ExcNotInitialized());
template <typename number>
void
-PreconditionLU<number>::Tvmult(BlockVector<number> & dst,
+PreconditionLU<number>::Tvmult(BlockVector<number> &dst,
const BlockVector<number> &src) const
{
Assert(mem != nullptr, ExcNotInitialized());
void
CommunicationPattern::reinit(const types::global_dof_index local_size,
- const IndexSet & ghost_indices,
+ const IndexSet &ghost_indices,
const MPI_Comm communicator)
{
clear();
void
CommunicationPattern::export_to_ghosted_array_start(
const ArrayView<const Number> &src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &dst) const
{
auto datatype = Utilities::MPI::mpi_type_id_for_type<Number>;
void
CommunicationPattern::export_to_ghosted_array_finish(
const ArrayView<const Number> &src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &dst) const
{
auto datatype = Utilities::MPI::mpi_type_id_for_type<Number>;
void
CommunicationPattern::export_to_ghosted_array(
const ArrayView<const Number> &src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &dst) const
{
export_to_ghosted_array_start(src, dst);
export_to_ghosted_array_finish(src, dst);
CommunicationPattern::import_from_ghosted_array_start(
const VectorOperation::values op,
const ArrayView<const Number> &src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &dst) const
{
MPI_Op mpiop = (op == VectorOperation::insert) ? MPI_REPLACE : MPI_SUM;
auto datatype = Utilities::MPI::mpi_type_id_for_type<Number>;
CommunicationPattern::import_from_ghosted_array_finish(
const VectorOperation::values op,
const ArrayView<const Number> &src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &dst) const
{
MPI_Op mpiop = (op == VectorOperation::insert) ? MPI_REPLACE : MPI_SUM;
auto datatype = Utilities::MPI::mpi_type_id_for_type<Number>;
CommunicationPattern::import_from_ghosted_array(
const VectorOperation::values op,
const ArrayView<const Number> &src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &dst) const
{
import_from_ghosted_array_start(op, src, dst);
import_from_ghosted_array_finish(op, src, dst);
void
Partitioner::export_to_ghosted_array_finish(
const ArrayView<const Number> &src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &dst) const
{
if (dst.size() == n_ghost_indices_larger)
{
template <typename Number>
void
Partitioner::export_to_ghosted_array(const ArrayView<const Number> &src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &dst) const
{
export_to_ghosted_array_start(src, dst);
export_to_ghosted_array_finish(src, dst);
Partitioner::import_from_ghosted_array_start(
const VectorOperation::values op,
const ArrayView<const Number> &src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &dst) const
{
if (src.size() == n_ghost_indices_larger)
{
Partitioner::import_from_ghosted_array_finish(
const VectorOperation::values op,
const ArrayView<const Number> &src,
- const ArrayView<Number> & dst) const
+ const ArrayView<Number> &dst) const
{
if (src.size() == n_ghost_indices_larger)
{
template void
CommunicationPattern::export_to_ghosted_array(
const ArrayView<const S> &src,
- const ArrayView<S> & dst) const;
+ const ArrayView<S> &dst) const;
template void
CommunicationPattern::export_to_ghosted_array_start(
const ArrayView<const S> &src,
- const ArrayView<S> & dst) const;
+ const ArrayView<S> &dst) const;
template void
CommunicationPattern::export_to_ghosted_array_finish(
const ArrayView<const S> &src,
- const ArrayView<S> & dst) const;
+ const ArrayView<S> &dst) const;
template void
CommunicationPattern::import_from_ghosted_array(
const VectorOperation::values op,
- const ArrayView<const S> & src,
- const ArrayView<S> & dst) const;
+ const ArrayView<const S> &src,
+ const ArrayView<S> &dst) const;
template void
CommunicationPattern::import_from_ghosted_array_start(
const VectorOperation::values op,
- const ArrayView<const S> & src,
- const ArrayView<S> & dst) const;
+ const ArrayView<const S> &src,
+ const ArrayView<S> &dst) const;
template void
CommunicationPattern::import_from_ghosted_array_finish(
const VectorOperation::values op,
- const ArrayView<const S> & src,
- const ArrayView<S> & dst) const;
+ const ArrayView<const S> &src,
+ const ArrayView<S> &dst) const;
template void
Partitioner::export_to_ghosted_array(const ArrayView<const S> &src,
- const ArrayView<S> & dst) const;
+ const ArrayView<S> &dst) const;
template void
Partitioner::export_to_ghosted_array_start(const ArrayView<const S> &src,
template void
Partitioner::export_to_ghosted_array_finish(
const ArrayView<const S> &src,
- const ArrayView<S> & dst) const;
+ const ArrayView<S> &dst) const;
template void
Partitioner::import_from_ghosted_array(const VectorOperation::values op,
- const ArrayView<const S> & src,
+ const ArrayView<const S> &src,
const ArrayView<S> &dst) const;
template void
Partitioner::import_from_ghosted_array_start(
const VectorOperation::values op,
- const ArrayView<const S> & src,
- const ArrayView<S> & dst) const;
+ const ArrayView<const S> &src,
+ const ArrayView<S> &dst) const;
template void
Partitioner::import_from_ghosted_array_finish(
const VectorOperation::values op,
- const ArrayView<const S> & src,
- const ArrayView<S> & dst) const;
+ const ArrayView<const S> &src,
+ const ArrayView<S> &dst) const;
\}
}
// get a representation of the present row
PetscInt ncols;
- const PetscInt * colnums;
+ const PetscInt *colnums;
const PetscScalar *values;
PetscErrorCode ierr =
// get a representation of the present
// row
PetscInt ncols;
- const PetscInt * colnums;
+ const PetscInt *colnums;
const PetscScalar *values;
// TODO: this is probably horribly inefficient; we should lobby for a way to
void
perform_mmult(const MatrixBase &inputleft,
const MatrixBase &inputright,
- MatrixBase & result,
+ MatrixBase &result,
const VectorBase &V,
const bool transpose_left)
{
} // namespace internals
void
- MatrixBase::mmult(MatrixBase & C,
+ MatrixBase::mmult(MatrixBase &C,
const MatrixBase &B,
const VectorBase &V) const
{
}
void
- MatrixBase::Tmmult(MatrixBase & C,
+ MatrixBase::Tmmult(MatrixBase &C,
const MatrixBase &B,
const VectorBase &V) const
{
}
PetscScalar
- MatrixBase::residual(VectorBase & dst,
+ MatrixBase::residual(VectorBase &dst,
const VectorBase &x,
const VectorBase &b) const
{
local_range();
PetscInt ncols;
- const PetscInt * colnums;
+ const PetscInt *colnums;
const PetscScalar *values;
MatrixBase::size_type row;
// object and link the given matrix A
// to the matrix-vector multiplication
// of this MatrixFree object,
- void * this_object;
+ void *this_object;
const PetscErrorCode ierr = MatShellGetContext(A, &this_object);
AssertThrow(ierr == 0, ExcPETScError(ierr));
void
- BlockSparseMatrix::reinit(const std::vector<IndexSet> & rows,
- const std::vector<IndexSet> & cols,
+ BlockSparseMatrix::reinit(const std::vector<IndexSet> &rows,
+ const std::vector<IndexSet> &cols,
const BlockDynamicSparsityPattern &bdsp,
const MPI_Comm com)
{
}
void
- BlockSparseMatrix::reinit(const std::vector<IndexSet> & sizes,
+ BlockSparseMatrix::reinit(const std::vector<IndexSet> &sizes,
const BlockDynamicSparsityPattern &bdsp,
const MPI_Comm com)
{
template <typename SparsityPatternType>
SparseMatrix::SparseMatrix(
const MPI_Comm communicator,
- const SparsityPatternType & sparsity_pattern,
+ const SparsityPatternType &sparsity_pattern,
const std::vector<size_type> &local_rows_per_process,
const std::vector<size_type> &local_columns_per_process,
const unsigned int this_process,
template <typename SparsityPatternType>
void
- SparseMatrix::reinit(const IndexSet & local_rows,
- const IndexSet & local_active_rows,
- const IndexSet & local_columns,
- const IndexSet & local_active_columns,
+ SparseMatrix::reinit(const IndexSet &local_rows,
+ const IndexSet &local_active_rows,
+ const IndexSet &local_columns,
+ const IndexSet &local_active_columns,
const SparsityPatternType &sparsity_pattern,
const MPI_Comm communicator)
{
void
SparseMatrix::reinit(
const MPI_Comm communicator,
- const SparsityPatternType & sparsity_pattern,
+ const SparsityPatternType &sparsity_pattern,
const std::vector<size_type> &local_rows_per_process,
const std::vector<size_type> &local_columns_per_process,
const unsigned int this_process,
template <typename SparsityPatternType>
void
- SparseMatrix::reinit(const IndexSet & local_rows,
+ SparseMatrix::reinit(const IndexSet &local_rows,
const SparsityPatternType &sparsity_pattern,
const MPI_Comm communicator)
{
template <typename SparsityPatternType>
void
- SparseMatrix::reinit(const IndexSet & local_rows,
- const IndexSet & local_columns,
+ SparseMatrix::reinit(const IndexSet &local_rows,
+ const IndexSet &local_columns,
const SparsityPatternType &sparsity_pattern,
const MPI_Comm communicator)
{
template <typename SparsityPatternType>
void
SparseMatrix::do_reinit(const MPI_Comm communicator,
- const IndexSet & local_rows,
- const IndexSet & local_columns,
+ const IndexSet &local_rows,
+ const IndexSet &local_columns,
const SparsityPatternType &sparsity_pattern)
{
Assert(sparsity_pattern.n_rows() == local_rows.size(),
void
SparseMatrix::do_reinit(
const MPI_Comm communicator,
- const SparsityPatternType & sparsity_pattern,
+ const SparsityPatternType &sparsity_pattern,
const std::vector<size_type> &local_rows_per_process,
const std::vector<size_type> &local_columns_per_process,
const unsigned int this_process,
template <typename SparsityPatternType>
void
SparseMatrix::do_reinit(const MPI_Comm communicator,
- const IndexSet & local_rows,
- const IndexSet & local_active_rows,
- const IndexSet & local_columns,
- const IndexSet & local_active_columns,
+ const IndexSet &local_rows,
+ const IndexSet &local_active_rows,
+ const IndexSet &local_columns,
+ const IndexSet &local_active_columns,
const SparsityPatternType &sparsity_pattern)
{
# if DEAL_II_PETSC_VERSION_GTE(3, 10, 0)
}
void
- SparseMatrix::mmult(SparseMatrix & C,
+ SparseMatrix::mmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V) const
+ const MPI::Vector &V) const
{
// Simply forward to the protected member function of the base class
// that takes abstract matrix and vector arguments (to which the compiler
}
void
- SparseMatrix::Tmmult(SparseMatrix & C,
+ SparseMatrix::Tmmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V) const
+ const MPI::Vector &V) const
{
// Simply forward to the protected member function of the base class
// that takes abstract matrix and vector arguments (to which the compiler
void
- Vector::print(std::ostream & out,
+ Vector::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool across) const
- PreconditionJacobi::PreconditionJacobi(const MatrixBase & matrix,
+ PreconditionJacobi::PreconditionJacobi(const MatrixBase &matrix,
const AdditionalData &additional_data)
: PreconditionBase(matrix.get_mpi_communicator())
{
void
- PreconditionJacobi::initialize(const MatrixBase & matrix_,
+ PreconditionJacobi::initialize(const MatrixBase &matrix_,
const AdditionalData &additional_data_)
{
clear();
PreconditionBlockJacobi::PreconditionBlockJacobi(
- const MatrixBase & matrix,
+ const MatrixBase &matrix,
const AdditionalData &additional_data)
: PreconditionBase(matrix.get_mpi_communicator())
{
void
- PreconditionBlockJacobi::initialize(const MatrixBase & matrix_,
+ PreconditionBlockJacobi::initialize(const MatrixBase &matrix_,
const AdditionalData &additional_data_)
{
clear();
- PreconditionSOR::PreconditionSOR(const MatrixBase & matrix,
+ PreconditionSOR::PreconditionSOR(const MatrixBase &matrix,
const AdditionalData &additional_data)
: PreconditionBase(matrix.get_mpi_communicator())
{
void
- PreconditionSOR::initialize(const MatrixBase & matrix_,
+ PreconditionSOR::initialize(const MatrixBase &matrix_,
const AdditionalData &additional_data_)
{
clear();
- PreconditionSSOR::PreconditionSSOR(const MatrixBase & matrix,
+ PreconditionSSOR::PreconditionSSOR(const MatrixBase &matrix,
const AdditionalData &additional_data)
: PreconditionBase(matrix.get_mpi_communicator())
{
void
- PreconditionSSOR::initialize(const MatrixBase & matrix_,
+ PreconditionSSOR::initialize(const MatrixBase &matrix_,
const AdditionalData &additional_data_)
{
clear();
- PreconditionICC::PreconditionICC(const MatrixBase & matrix,
+ PreconditionICC::PreconditionICC(const MatrixBase &matrix,
const AdditionalData &additional_data)
: PreconditionBase(matrix.get_mpi_communicator())
{
void
- PreconditionICC::initialize(const MatrixBase & matrix_,
+ PreconditionICC::initialize(const MatrixBase &matrix_,
const AdditionalData &additional_data_)
{
clear();
- PreconditionILU::PreconditionILU(const MatrixBase & matrix,
+ PreconditionILU::PreconditionILU(const MatrixBase &matrix,
const AdditionalData &additional_data)
: PreconditionBase(matrix.get_mpi_communicator())
{
void
- PreconditionILU::initialize(const MatrixBase & matrix_,
+ PreconditionILU::initialize(const MatrixBase &matrix_,
const AdditionalData &additional_data_)
{
clear();
PreconditionBoomerAMG::PreconditionBoomerAMG(
- const MatrixBase & matrix,
+ const MatrixBase &matrix,
const AdditionalData &additional_data)
: PreconditionBase(matrix.get_mpi_communicator())
{
void
- PreconditionBoomerAMG::initialize(const MatrixBase & matrix_,
+ PreconditionBoomerAMG::initialize(const MatrixBase &matrix_,
const AdditionalData &additional_data_)
{
# ifdef DEAL_II_PETSC_WITH_HYPRE
PreconditionParaSails::PreconditionParaSails(
- const MatrixBase & matrix,
+ const MatrixBase &matrix,
const AdditionalData &additional_data)
: PreconditionBase(matrix.get_mpi_communicator())
{
void
- PreconditionParaSails::initialize(const MatrixBase & matrix_,
+ PreconditionParaSails::initialize(const MatrixBase &matrix_,
const AdditionalData &additional_data_)
{
clear();
- PreconditionNone::PreconditionNone(const MatrixBase & matrix,
+ PreconditionNone::PreconditionNone(const MatrixBase &matrix,
const AdditionalData &additional_data)
: PreconditionBase(matrix.get_mpi_communicator())
{
void
- PreconditionNone::initialize(const MatrixBase & matrix_,
+ PreconditionNone::initialize(const MatrixBase &matrix_,
const AdditionalData &additional_data_)
{
clear();
- PreconditionLU::PreconditionLU(const MatrixBase & matrix,
+ PreconditionLU::PreconditionLU(const MatrixBase &matrix,
const AdditionalData &additional_data)
: PreconditionBase(matrix.get_mpi_communicator())
{
void
- PreconditionLU::initialize(const MatrixBase & matrix_,
+ PreconditionLU::initialize(const MatrixBase &matrix_,
const AdditionalData &additional_data_)
{
clear();
template <int dim>
- PreconditionBDDC<dim>::PreconditionBDDC(const MatrixBase & matrix,
+ PreconditionBDDC<dim>::PreconditionBDDC(const MatrixBase &matrix,
const AdditionalData &additional_data)
: PreconditionBase(matrix.get_mpi_communicator())
{
template <int dim>
void
- PreconditionBDDC<dim>::initialize(const MatrixBase & matrix_,
+ PreconditionBDDC<dim>::initialize(const MatrixBase &matrix_,
const AdditionalData &additional_data_)
{
clear();
void
- SolverBase::solve(const MatrixBase & A,
- VectorBase & x,
- const VectorBase & b,
+ SolverBase::solve(const MatrixBase &A,
+ VectorBase &x,
+ const VectorBase &b,
const PreconditionBase &preconditioner)
{
// first create a solver object if this
const PetscInt iteration,
const PetscReal residual_norm,
KSPConvergedReason *reason,
- void * solver_control_x)
+ void *solver_control_x)
{
PetscFunctionBeginUser;
SolverControl &solver_control =
- SolverRichardson::SolverRichardson(SolverControl & cn,
+ SolverRichardson::SolverRichardson(SolverControl &cn,
const AdditionalData &data)
: SolverBase(cn)
, additional_data(data)
/* ---------------------- SolverChebychev ------------------------ */
- SolverChebychev::SolverChebychev(SolverControl & cn,
+ SolverChebychev::SolverChebychev(SolverControl &cn,
const AdditionalData &data)
: SolverBase(cn)
, additional_data(data)
/* ---------------------- SparseDirectMUMPS------------------------ */
- SparseDirectMUMPS::SparseDirectMUMPS(SolverControl & cn,
+ SparseDirectMUMPS::SparseDirectMUMPS(SolverControl &cn,
const AdditionalData &data)
: SolverBase(cn)
, additional_data(data)
void
SparseDirectMUMPS::solve(const MatrixBase &A,
- VectorBase & x,
+ VectorBase &x,
const VectorBase &b)
{
# ifdef DEAL_II_PETSC_WITH_MUMPS
}
void
- SparseMatrix::mmult(SparseMatrix & C,
+ SparseMatrix::mmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V) const
+ const MPI::Vector &V) const
{
// Simply forward to the protected member function of the base class
// that takes abstract matrix and vector arguments (to which the compiler
}
void
- SparseMatrix::Tmmult(SparseMatrix & C,
+ SparseMatrix::Tmmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V) const
+ const MPI::Vector &V) const
{
// Simply forward to the protected member function of the base class
// that takes abstract matrix and vector arguments (to which the compiler
void
- VectorBase::set(const std::vector<size_type> & indices,
+ VectorBase::set(const std::vector<size_type> &indices,
const std::vector<PetscScalar> &values)
{
Assert(indices.size() == values.size(),
void
- VectorBase::add(const std::vector<size_type> & indices,
+ VectorBase::add(const std::vector<size_type> &indices,
const std::vector<PetscScalar> &values)
{
Assert(indices.size() == values.size(),
void
- VectorBase::add(const std::vector<size_type> & indices,
+ VectorBase::add(const std::vector<size_type> &indices,
const ::dealii::Vector<PetscScalar> &values)
{
Assert(indices.size() == values.size(),
void
VectorBase::add(const size_type n_elements,
- const size_type * indices,
+ const size_type *indices,
const PetscScalar *values)
{
do_set_add_operation(n_elements, indices, values, true);
void
- VectorBase::print(std::ostream & out,
+ VectorBase::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool across) const
void
VectorBase::do_set_add_operation(const size_type n_elements,
- const size_type * indices,
+ const size_type *indices,
const PetscScalar *values,
const bool add_values)
{
const char trans,
const char diag,
const types::blas_int n,
- const Number * a,
+ const Number *a,
const types::blas_int lda,
- Number * x,
+ Number *x,
const types::blas_int incx)
{
trmv(&uplo, &trans, &diag, &n, a, &lda, x, &incx);
const char diag,
const types::blas_int n,
const types::blas_int nrhs,
- const Number * a,
+ const Number *a,
const types::blas_int lda,
- Number * b,
+ Number *b,
const types::blas_int ldb,
- types::blas_int * info)
+ types::blas_int *info)
{
trtrs(&uplo, &trans, &diag, &n, &nrhs, a, &lda, b, &ldb, info);
}
template <typename NumberType>
ScaLAPACKMatrix<NumberType>::ScaLAPACKMatrix(
- const std::string & filename,
+ const std::string &filename,
const std::shared_ptr<const Utilities::MPI::ProcessGrid> &process_grid,
const size_type row_block_size,
const size_type column_block_size)
template <typename NumberType>
void
ScaLAPACKMatrix<NumberType>::copy_to(
- ScaLAPACKMatrix<NumberType> & B,
+ ScaLAPACKMatrix<NumberType> &B,
const std::pair<unsigned int, unsigned int> &offset_A,
const std::pair<unsigned int, unsigned int> &offset_B,
const std::pair<unsigned int, unsigned int> &submatrix_size) const
std::array<int, 9> desc_A, desc_B;
const NumberType *loc_vals_A = nullptr;
- NumberType * loc_vals_B = nullptr;
+ NumberType *loc_vals_B = nullptr;
// Note: the function pgemr2d has to be called for all processes in the union
// BLACS context If the calling process is not part of the BLACS context of A,
union_n_process_columns);
const NumberType *loc_vals_source = nullptr;
- NumberType * loc_vals_dest = nullptr;
+ NumberType *loc_vals_dest = nullptr;
if (this->grid->mpi_process_is_active && (this->values.size() > 0))
{
else
// process is active in the process grid
if (this->grid->mpi_process_is_active)
- dest.values = this->values;
+ dest.values = this->values;
dest.state = state;
dest.property = property;
ScaLAPACKMatrix<NumberType>::mult(const NumberType b,
const ScaLAPACKMatrix<NumberType> &B,
const NumberType c,
- ScaLAPACKMatrix<NumberType> & C,
+ ScaLAPACKMatrix<NumberType> &C,
const bool transpose_A,
const bool transpose_B) const
{
template <typename NumberType>
void
-ScaLAPACKMatrix<NumberType>::mmult(ScaLAPACKMatrix<NumberType> & C,
+ScaLAPACKMatrix<NumberType>::mmult(ScaLAPACKMatrix<NumberType> &C,
const ScaLAPACKMatrix<NumberType> &B,
const bool adding) const
{
template <typename NumberType>
void
-ScaLAPACKMatrix<NumberType>::Tmmult(ScaLAPACKMatrix<NumberType> & C,
+ScaLAPACKMatrix<NumberType>::Tmmult(ScaLAPACKMatrix<NumberType> &C,
const ScaLAPACKMatrix<NumberType> &B,
const bool adding) const
{
template <typename NumberType>
void
-ScaLAPACKMatrix<NumberType>::mTmult(ScaLAPACKMatrix<NumberType> & C,
+ScaLAPACKMatrix<NumberType>::mTmult(ScaLAPACKMatrix<NumberType> &C,
const ScaLAPACKMatrix<NumberType> &B,
const bool adding) const
{
template <typename NumberType>
void
-ScaLAPACKMatrix<NumberType>::TmTmult(ScaLAPACKMatrix<NumberType> & C,
+ScaLAPACKMatrix<NumberType>::TmTmult(ScaLAPACKMatrix<NumberType> &C,
const ScaLAPACKMatrix<NumberType> &B,
const bool adding) const
{
ScaLAPACKMatrix<NumberType>::eigenpairs_symmetric(
const bool compute_eigenvectors,
const std::pair<unsigned int, unsigned int> &eigenvalue_idx,
- const std::pair<NumberType, NumberType> & eigenvalue_limits)
+ const std::pair<NumberType, NumberType> &eigenvalue_limits)
{
Assert(state == LAPACKSupport::matrix,
ExcMessage(
ScaLAPACKMatrix<NumberType>::eigenpairs_symmetric_MRRR(
const bool compute_eigenvectors,
const std::pair<unsigned int, unsigned int> &eigenvalue_idx,
- const std::pair<NumberType, NumberType> & eigenvalue_limits)
+ const std::pair<NumberType, NumberType> &eigenvalue_limits)
{
Assert(state == LAPACKSupport::matrix,
ExcMessage(
template <typename NumberType>
void
ScaLAPACKMatrix<NumberType>::save(
- const std::string & filename,
+ const std::string &filename,
const std::pair<unsigned int, unsigned int> &chunk_size) const
{
# ifndef DEAL_II_WITH_HDF5
template <typename NumberType>
void
ScaLAPACKMatrix<NumberType>::save_serial(
- const std::string & filename,
+ const std::string &filename,
const std::pair<unsigned int, unsigned int> &chunk_size) const
{
# ifndef DEAL_II_WITH_HDF5
template <typename NumberType>
void
ScaLAPACKMatrix<NumberType>::save_parallel(
- const std::string & filename,
+ const std::string &filename,
const std::pair<unsigned int, unsigned int> &chunk_size) const
{
# ifndef DEAL_II_WITH_HDF5
{
template <typename NumberType>
void
- scale_columns(ScaLAPACKMatrix<NumberType> & matrix,
+ scale_columns(ScaLAPACKMatrix<NumberType> &matrix,
const ArrayView<const NumberType> &factors)
{
Assert(matrix.n() == factors.size(),
template <typename NumberType>
void
- scale_rows(ScaLAPACKMatrix<NumberType> & matrix,
+ scale_rows(ScaLAPACKMatrix<NumberType> &matrix,
const ArrayView<const NumberType> &factors)
{
Assert(matrix.m() == factors.size(),
void
SolverBase::get_eigenpair(const unsigned int index,
- PetscScalar & eigenvalues,
+ PetscScalar &eigenvalues,
PETScWrappers::VectorBase &eigenvectors)
{
// get converged eigenpair
void
SolverBase::get_eigenpair(const unsigned int index,
- double & real_eigenvalues,
- double & imag_eigenvalues,
+ double &real_eigenvalues,
+ double &imag_eigenvalues,
PETScWrappers::VectorBase &real_eigenvectors,
PETScWrappers::VectorBase &imag_eigenvectors)
{
/* ---------------------- SolverKrylovSchur ------------------------ */
- SolverKrylovSchur::SolverKrylovSchur(SolverControl & cn,
+ SolverKrylovSchur::SolverKrylovSchur(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data)
: SolverBase(cn, mpi_communicator)
- SolverArnoldi::SolverArnoldi(SolverControl & cn,
+ SolverArnoldi::SolverArnoldi(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data)
: SolverBase(cn, mpi_communicator)
- SolverLanczos::SolverLanczos(SolverControl & cn,
+ SolverLanczos::SolverLanczos(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data)
: SolverBase(cn, mpi_communicator)
/* ----------------------- Power ------------------------- */
- SolverPower::SolverPower(SolverControl & cn,
+ SolverPower::SolverPower(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data)
: SolverBase(cn, mpi_communicator)
SolverGeneralizedDavidson::SolverGeneralizedDavidson(
- SolverControl & cn,
+ SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data)
: SolverBase(cn, mpi_communicator)
/* ---------------------- LAPACK ------------------------- */
- SolverLAPACK::SolverLAPACK(SolverControl & cn,
+ SolverLAPACK::SolverLAPACK(SolverControl &cn,
const MPI_Comm mpi_communicator,
const AdditionalData &data)
: SolverBase(cn, mpi_communicator)
ConsecutiveControl &
ConsecutiveControl::operator=(const SolverControl &c)
{
- SolverControl::operator =(c);
+ SolverControl::operator=(c);
n_consecutive_iterations = 1;
n_converged_iterations = 0;
return *this;
template <class Matrix>
void
-SparseDirectUMFPACK::solve(const Matrix & matrix,
+SparseDirectUMFPACK::solve(const Matrix &matrix,
Vector<double> &rhs_and_solution,
const bool transpose /*=false*/)
{
template <class Matrix>
void
-SparseDirectUMFPACK::solve(const Matrix & matrix,
+SparseDirectUMFPACK::solve(const Matrix &matrix,
Vector<std::complex<double>> &rhs_and_solution,
const bool transpose /*=false*/)
{
template <class Matrix>
void
-SparseDirectUMFPACK::solve(const Matrix & matrix,
+SparseDirectUMFPACK::solve(const Matrix &matrix,
BlockVector<double> &rhs_and_solution,
const bool transpose /*=false*/)
{
template <class Matrix>
void
-SparseDirectUMFPACK::solve(const Matrix & matrix,
+SparseDirectUMFPACK::solve(const Matrix &matrix,
BlockVector<std::complex<double>> &rhs_and_solution,
const bool transpose /*=false*/)
{
void
-SparseDirectUMFPACK::vmult(BlockVector<double> & dst,
+SparseDirectUMFPACK::vmult(BlockVector<double> &dst,
const BlockVector<double> &src) const
{
dst = src;
void
-SparseDirectUMFPACK::Tvmult(Vector<double> & dst,
+SparseDirectUMFPACK::Tvmult(Vector<double> &dst,
const Vector<double> &src) const
{
dst = src;
void
-SparseDirectUMFPACK::Tvmult(BlockVector<double> & dst,
+SparseDirectUMFPACK::Tvmult(BlockVector<double> &dst,
const BlockVector<double> &src) const
{
dst = src;
template class SparseVanka<double>;
template void
-SparseVanka<double>::vmult<float>(Vector<float> & dst,
+SparseVanka<double>::vmult<float>(Vector<float> &dst,
const Vector<float> &src) const;
template void
-SparseVanka<double>::vmult<double>(Vector<double> & dst,
+SparseVanka<double>::vmult<double>(Vector<double> &dst,
const Vector<double> &src) const;
template class SparseBlockVanka<double>;
template void
-SparseBlockVanka<double>::vmult<float>(Vector<float> & dst,
+SparseBlockVanka<double>::vmult<float>(Vector<float> &dst,
const Vector<float> &src) const;
template void
-SparseBlockVanka<double>::vmult<double>(Vector<double> & dst,
+SparseBlockVanka<double>::vmult<double>(Vector<double> &dst,
const Vector<double> &src) const;
DEAL_II_NAMESPACE_CLOSE
// anyway because it's the diagonal entry of a square
// matrix
if (matrix_is_square && (col == row))
- {
- column_indices[current_index] = row;
- ++current_index;
- }
+ {
+ column_indices[current_index] = row;
+ ++current_index;
+ }
// check that we really added the correct number of indices
Assert(current_index == entries_per_row[row], ExcInternalError());
void
-SparsityPattern::add_row_entries(const size_type & row,
+SparsityPattern::add_row_entries(const size_type &row,
const ArrayView<const size_type> &columns,
const bool indices_are_sorted)
{
namespace
{
void
- partition_metis(const SparsityPattern & sparsity_pattern,
+ partition_metis(const SparsityPattern &sparsity_pattern,
const std::vector<unsigned int> &cell_weights,
const unsigned int n_partitions,
- std::vector<unsigned int> & partition_indices)
+ std::vector<unsigned int> &partition_indices)
{
// Make sure that METIS is actually
// installed and detected
ZOLTAN_ID_PTR /*localID*/,
int * /*num_edges*/,
ZOLTAN_ID_PTR nborGID,
- int * nborProc,
+ int *nborProc,
int /*wgt_dim*/,
float * /*ewgts*/,
int *ierr)
*ierr = ZOLTAN_OK;
ZOLTAN_ID_PTR nextNborGID = nborGID;
- int * nextNborProc = nborProc;
+ int *nextNborProc = nborProc;
// Loop through rows corresponding to indices in globalID implicitly
for (SparsityPattern::size_type i = 0;
void
- partition_zoltan(const SparsityPattern & sparsity_pattern,
+ partition_zoltan(const SparsityPattern &sparsity_pattern,
const std::vector<unsigned int> &cell_weights,
const unsigned int n_partitions,
- std::vector<unsigned int> & partition_indices)
+ std::vector<unsigned int> &partition_indices)
{
// Make sure that ZOLTAN is actually
// installed and detected
int num_import = 0;
ZOLTAN_ID_PTR import_global_ids = nullptr;
ZOLTAN_ID_PTR import_local_ids = nullptr;
- int * import_procs = nullptr;
- int * import_to_part = nullptr;
+ int *import_procs = nullptr;
+ int *import_to_part = nullptr;
int num_export = 0;
ZOLTAN_ID_PTR export_global_ids = nullptr;
ZOLTAN_ID_PTR export_local_ids = nullptr;
- int * export_procs = nullptr;
- int * export_to_part = nullptr;
+ int *export_procs = nullptr;
+ int *export_to_part = nullptr;
// call partitioner
const int rc = zz->LB_Partition(changes,
void
- partition(const SparsityPattern & sparsity_pattern,
+ partition(const SparsityPattern &sparsity_pattern,
const unsigned int n_partitions,
std::vector<unsigned int> &partition_indices,
const Partitioner partitioner)
void
- partition(const SparsityPattern & sparsity_pattern,
+ partition(const SparsityPattern &sparsity_pattern,
const std::vector<unsigned int> &cell_weights,
const unsigned int n_partitions,
- std::vector<unsigned int> & partition_indices,
+ std::vector<unsigned int> &partition_indices,
const Partitioner partitioner)
{
Assert(sparsity_pattern.n_rows() == sparsity_pattern.n_cols(),
unsigned int
- color_sparsity_pattern(const SparsityPattern & sparsity_pattern,
+ color_sparsity_pattern(const SparsityPattern &sparsity_pattern,
std::vector<unsigned int> &color_indices)
{
// Make sure that ZOLTAN is actually
zz->Set_Edge_List_Multi_Fn(get_edge_list, &graph);
// Variables needed by coloring function
- int num_gid_entries = 1;
- const int num_objects = graph.n_rows();
+ int num_gid_entries = 1;
+ const int num_objects = graph.n_rows();
// Preallocate input variables. Element type fixed by ZOLTAN.
std::vector<ZOLTAN_ID_TYPE> global_ids(num_objects);
- std::vector<int> color_exp(num_objects);
+ std::vector<int> color_exp(num_objects);
// Set ids for which coloring needs to be done
for (int i = 0; i < num_objects; ++i)
*/
DynamicSparsityPattern::size_type
find_unnumbered_starting_index(
- const DynamicSparsityPattern & sparsity,
+ const DynamicSparsityPattern &sparsity,
const std::vector<DynamicSparsityPattern::size_type> &new_indices)
{
DynamicSparsityPattern::size_type starting_point =
void
reorder_Cuthill_McKee(
- const DynamicSparsityPattern & sparsity,
- std::vector<DynamicSparsityPattern::size_type> & new_indices,
+ const DynamicSparsityPattern &sparsity,
+ std::vector<DynamicSparsityPattern::size_type> &new_indices,
const std::vector<DynamicSparsityPattern::size_type> &starting_indices)
{
Assert(sparsity.n_rows() == sparsity.n_cols(),
{
void
reorder_hierarchical(
- const DynamicSparsityPattern & connectivity,
+ const DynamicSparsityPattern &connectivity,
std::vector<DynamicSparsityPattern::size_type> &renumbering)
{
AssertDimension(connectivity.n_rows(), connectivity.n_cols());
void
reorder_hierarchical(
- const DynamicSparsityPattern & connectivity,
+ const DynamicSparsityPattern &connectivity,
std::vector<DynamicSparsityPattern::size_type> &renumbering)
{
// the internal renumbering keeps the numbering the wrong way around (but
void
gather_sparsity_pattern(DynamicSparsityPattern &dsp,
- const IndexSet & locally_owned_rows,
+ const IndexSet &locally_owned_rows,
const MPI_Comm mpi_comm,
- const IndexSet & locally_relevant_rows)
+ const IndexSet &locally_relevant_rows)
{
using map_vec_t =
std::map<unsigned int, std::vector<DynamicSparsityPattern::size_type>>;
void
distribute_sparsity_pattern(
- DynamicSparsityPattern & dsp,
+ DynamicSparsityPattern &dsp,
const std::vector<DynamicSparsityPattern::size_type> &rows_per_cpu,
const MPI_Comm mpi_comm,
- const IndexSet & myrange)
+ const IndexSet &myrange)
{
const unsigned int myid = Utilities::MPI::this_mpi_process(mpi_comm);
std::vector<DynamicSparsityPattern::size_type> start_index(
void
distribute_sparsity_pattern(DynamicSparsityPattern &dsp,
- const IndexSet & locally_owned_rows,
+ const IndexSet &locally_owned_rows,
const MPI_Comm mpi_comm,
- const IndexSet & locally_relevant_rows)
+ const IndexSet &locally_relevant_rows)
{
IndexSet requested_rows(locally_relevant_rows);
requested_rows.subtract_set(locally_owned_rows);
distribute_sparsity_pattern(BlockDynamicSparsityPattern &dsp,
const std::vector<IndexSet> &owned_set_per_cpu,
const MPI_Comm mpi_comm,
- const IndexSet & myrange)
+ const IndexSet &myrange)
{
const unsigned int myid = Utilities::MPI::this_mpi_process(mpi_comm);
distribute_sparsity_pattern(dsp,
void
distribute_sparsity_pattern(BlockDynamicSparsityPattern &dsp,
- const IndexSet & locally_owned_rows,
+ const IndexSet &locally_owned_rows,
const MPI_Comm mpi_comm,
const IndexSet &locally_relevant_rows)
{
{
template void select_vmult<1>(
deal_II_scalar_vectorized * dst,
- const deal_II_scalar_vectorized * src,
+ const deal_II_scalar_vectorized *src,
AlignedVector<deal_II_scalar_vectorized> &tmp,
const unsigned int n_rows,
const std::array<const deal_II_scalar_vectorized *, deal_II_dimension>
const std::array<const deal_II_scalar_vectorized *, deal_II_dimension>
&eigenvectors,
const std::array<const deal_II_scalar_vectorized *, deal_II_dimension>
- & eigenvalues,
+ &eigenvalues,
const deal_II_scalar_vectorized *inverted_eigenvalues);
}
{
template void select_vmult<1>(
deal_II_scalar * dst,
- const deal_II_scalar * src,
- AlignedVector<deal_II_scalar> & tmp,
+ const deal_II_scalar *src,
+ AlignedVector<deal_II_scalar> &tmp,
const unsigned int n_rows,
const std::array<const deal_II_scalar *, deal_II_dimension> &mass_matrix,
const std::array<const deal_II_scalar *, deal_II_dimension>
template void select_apply_inverse<1>(
deal_II_scalar * dst,
- const deal_II_scalar * src,
+ const deal_II_scalar *src,
const unsigned int n_rows,
const std::array<const deal_II_scalar *, deal_II_dimension> &eigenvectors,
const std::array<const deal_II_scalar *, deal_II_dimension> &eigenvalues,
template <typename number>
void
-TridiagonalMatrix<number>::vmult(Vector<number> & w,
+TridiagonalMatrix<number>::vmult(Vector<number> &w,
const Vector<number> &v,
const bool adding) const
{
template <typename number>
void
-TridiagonalMatrix<number>::vmult_add(Vector<number> & w,
+TridiagonalMatrix<number>::vmult_add(Vector<number> &w,
const Vector<number> &v) const
{
vmult(w, v, /*adding = */ true);
template <typename number>
void
-TridiagonalMatrix<number>::Tvmult(Vector<number> & w,
+TridiagonalMatrix<number>::Tvmult(Vector<number> &w,
const Vector<number> &v,
const bool adding) const
{
template <typename number>
void
-TridiagonalMatrix<number>::Tvmult_add(Vector<number> & w,
+TridiagonalMatrix<number>::Tvmult_add(Vector<number> &w,
const Vector<number> &v) const
{
Tvmult(w, v, true);
template <typename BlockSparsityPatternType>
void
BlockSparseMatrix::reinit(
- const std::vector<IndexSet> & parallel_partitioning,
+ const std::vector<IndexSet> ¶llel_partitioning,
const BlockSparsityPatternType &block_sparsity_pattern,
const MPI_Comm communicator,
const bool exchange_data)
void
BlockSparseMatrix::reinit(
- const std::vector<IndexSet> & parallel_partitioning,
+ const std::vector<IndexSet> ¶llel_partitioning,
const ::dealii::BlockSparseMatrix<double> &dealii_block_sparse_matrix,
const MPI_Comm communicator,
const double drop_tolerance)
TrilinosScalar
- BlockSparseMatrix::residual(MPI::BlockVector & dst,
+ BlockSparseMatrix::residual(MPI::BlockVector &dst,
const MPI::BlockVector &x,
const MPI::BlockVector &b) const
{
// above three more times. Use
// templates.
TrilinosScalar
- BlockSparseMatrix::residual(MPI::BlockVector & dst,
- const MPI::Vector & x,
+ BlockSparseMatrix::residual(MPI::BlockVector &dst,
+ const MPI::Vector &x,
const MPI::BlockVector &b) const
{
vmult(dst, x);
TrilinosScalar
- BlockSparseMatrix::residual(MPI::Vector & dst,
+ BlockSparseMatrix::residual(MPI::Vector &dst,
const MPI::BlockVector &x,
- const MPI::Vector & b) const
+ const MPI::Vector &b) const
{
vmult(dst, x);
dst -= b;
TrilinosScalar
- BlockSparseMatrix::residual(MPI::Vector & dst,
+ BlockSparseMatrix::residual(MPI::Vector &dst,
const MPI::Vector &x,
const MPI::Vector &b) const
{
void
BlockVector::reinit(
const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
- & partitioners,
+ &partitioners,
const bool make_ghosted,
const bool vector_writable)
{
void
BlockVector::import_nonlocal_data_for_fe(
const TrilinosWrappers::BlockSparseMatrix &m,
- const BlockVector & v)
+ const BlockVector &v)
{
AssertDimension(m.n_block_rows(), v.n_blocks());
AssertDimension(m.n_block_cols(), v.n_blocks());
void
- BlockVector::print(std::ostream & out,
+ BlockVector::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool across) const
void
Vector::extract_subvector_to(
const ArrayView<const types::global_dof_index> &indices,
- ArrayView<double> & elements) const
+ ArrayView<double> &elements) const
{
AssertDimension(indices.size(), elements.size());
const auto &vector = trilinos_vector();
// The TargetMap and the SourceMap have their roles inverted.
Epetra_FEVector source_vector(import_map.TargetMap());
- double * values = source_vector.Values();
+ double *values = source_vector.Values();
std::copy(V.begin(), V.end(), values);
if (operation == VectorOperation::insert)
{
// get a representation of the vector and
// loop over all the elements
- double * start_ptr = (*vector)[0];
+ double *start_ptr = (*vector)[0];
const double *ptr = start_ptr, *eptr = start_ptr + vector->MyLength();
unsigned int flag = 0;
while (ptr != eptr)
void
- Vector::print(std::ostream & out,
+ Vector::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool across) const
void
- PreconditionJacobi::initialize(const SparseMatrix & matrix,
+ PreconditionJacobi::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
// release memory before reallocation
void
- PreconditionSSOR::initialize(const SparseMatrix & matrix,
+ PreconditionSSOR::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
preconditioner.reset();
void
- PreconditionSOR::initialize(const SparseMatrix & matrix,
+ PreconditionSOR::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
preconditioner.reset();
void
- PreconditionBlockJacobi::initialize(const SparseMatrix & matrix,
+ PreconditionBlockJacobi::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
// release memory before reallocation
void
- PreconditionBlockSSOR::initialize(const SparseMatrix & matrix,
+ PreconditionBlockSSOR::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
preconditioner.reset();
void
- PreconditionBlockSOR::initialize(const SparseMatrix & matrix,
+ PreconditionBlockSOR::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
preconditioner.reset();
void
- PreconditionIC::initialize(const SparseMatrix & matrix,
+ PreconditionIC::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
preconditioner.reset();
void
- PreconditionILU::initialize(const SparseMatrix & matrix,
+ PreconditionILU::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
preconditioner.reset();
void
- PreconditionILUT::initialize(const SparseMatrix & matrix,
+ PreconditionILUT::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
preconditioner.reset();
void
- PreconditionBlockwiseDirect::initialize(const SparseMatrix & matrix,
+ PreconditionBlockwiseDirect::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
preconditioner.reset();
void
- PreconditionChebyshev::initialize(const SparseMatrix & matrix,
+ PreconditionChebyshev::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
preconditioner =
}
void
- PreconditionIdentity::vmult(dealii::Vector<double> & dst,
+ PreconditionIdentity::vmult(dealii::Vector<double> &dst,
const dealii::Vector<double> &src) const
{
dst = src;
}
void
- PreconditionIdentity::Tvmult(dealii::Vector<double> & dst,
+ PreconditionIdentity::Tvmult(dealii::Vector<double> &dst,
const dealii::Vector<double> &src) const
{
dst = src;
# ifndef DOXYGEN
void
PreconditionIdentity::vmult(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
dst = src;
void
PreconditionIdentity::Tvmult(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
dst = src;
const unsigned int smoother_sweeps,
const unsigned int smoother_overlap,
const bool output_details,
- const char * smoother_type,
- const char * coarse_type)
+ const char *smoother_type,
+ const char *coarse_type)
: elliptic(elliptic)
, higher_order_elements(higher_order_elements)
, n_cycles(n_cycles)
void
PreconditionAMG::AdditionalData::set_parameters(
- Teuchos::ParameterList & parameter_list,
+ Teuchos::ParameterList ¶meter_list,
std::unique_ptr<Epetra_MultiVector> &distributed_constant_modes,
- const Epetra_RowMatrix & matrix) const
+ const Epetra_RowMatrix &matrix) const
{
if (elliptic == true)
{
void
PreconditionAMG::AdditionalData::set_operator_null_space(
- Teuchos::ParameterList & parameter_list,
+ Teuchos::ParameterList ¶meter_list,
std::unique_ptr<Epetra_MultiVector> &ptr_distributed_constant_modes,
- const Epetra_RowMatrix & matrix) const
+ const Epetra_RowMatrix &matrix) const
{
const Epetra_Map &domain_map = matrix.OperatorDomainMap();
void
PreconditionAMG::AdditionalData::set_parameters(
- Teuchos::ParameterList & parameter_list,
+ Teuchos::ParameterList ¶meter_list,
std::unique_ptr<Epetra_MultiVector> &distributed_constant_modes,
- const SparseMatrix & matrix) const
+ const SparseMatrix &matrix) const
{
return set_parameters(parameter_list,
distributed_constant_modes,
void
PreconditionAMG::AdditionalData::set_operator_null_space(
- Teuchos::ParameterList & parameter_list,
+ Teuchos::ParameterList ¶meter_list,
std::unique_ptr<Epetra_MultiVector> &distributed_constant_modes,
- const SparseMatrix & matrix) const
+ const SparseMatrix &matrix) const
{
return set_operator_null_space(parameter_list,
distributed_constant_modes,
void
- PreconditionAMG::initialize(const SparseMatrix & matrix,
+ PreconditionAMG::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
initialize(matrix.trilinos_matrix(), additional_data);
void
PreconditionAMG::initialize(const Epetra_RowMatrix &matrix,
- const AdditionalData & additional_data)
+ const AdditionalData &additional_data)
{
// Build the AMG preconditioner.
Teuchos::ParameterList ml_parameters;
void
- PreconditionAMG::initialize(const SparseMatrix & matrix,
+ PreconditionAMG::initialize(const SparseMatrix &matrix,
const Teuchos::ParameterList &ml_parameters)
{
initialize(matrix.trilinos_matrix(), ml_parameters);
void
- PreconditionAMG::initialize(const Epetra_RowMatrix & matrix,
+ PreconditionAMG::initialize(const Epetra_RowMatrix &matrix,
const Teuchos::ParameterList &ml_parameters)
{
preconditioner.reset(
void
PreconditionAMG::initialize(
const ::dealii::SparseMatrix<number> &deal_ii_sparse_matrix,
- const AdditionalData & additional_data,
+ const AdditionalData &additional_data,
const double drop_tolerance,
- const ::dealii::SparsityPattern * use_this_sparsity)
+ const ::dealii::SparsityPattern *use_this_sparsity)
{
preconditioner.reset();
const size_type n_rows = deal_ii_sparse_matrix.m();
const unsigned int smoother_sweeps,
const unsigned int smoother_overlap,
const bool output_details,
- const char * smoother_type,
- const char * coarse_type)
+ const char *smoother_type,
+ const char *coarse_type)
: elliptic(elliptic)
, n_cycles(n_cycles)
, w_cycle(w_cycle)
void
- PreconditionAMGMueLu::initialize(const SparseMatrix & matrix,
+ PreconditionAMGMueLu::initialize(const SparseMatrix &matrix,
const AdditionalData &additional_data)
{
initialize(matrix.trilinos_matrix(), additional_data);
void
PreconditionAMGMueLu::initialize(const Epetra_CrsMatrix &matrix,
- const AdditionalData & additional_data)
+ const AdditionalData &additional_data)
{
// Build the AMG preconditioner.
Teuchos::ParameterList parameter_list;
void
- PreconditionAMGMueLu::initialize(const SparseMatrix & matrix,
+ PreconditionAMGMueLu::initialize(const SparseMatrix &matrix,
Teuchos::ParameterList &muelu_parameters)
{
initialize(matrix.trilinos_matrix(), muelu_parameters);
void
PreconditionAMGMueLu::initialize(
const ::dealii::SparseMatrix<number> &deal_ii_sparse_matrix,
- const AdditionalData & additional_data,
+ const AdditionalData &additional_data,
const double drop_tolerance,
- const ::dealii::SparsityPattern * use_this_sparsity)
+ const ::dealii::SparsityPattern *use_this_sparsity)
{
preconditioner.reset();
const size_type n_rows = deal_ii_sparse_matrix.m();
SolverBase::SolverBase(const SolverBase::SolverName solver_name,
- SolverControl & cn,
- const AdditionalData & data)
+ SolverControl &cn,
+ const AdditionalData &data)
: solver_name(solver_name)
, solver_control(cn)
, additional_data(data)
void
- SolverBase::solve(const SparseMatrix & A,
- MPI::Vector & x,
- const MPI::Vector & b,
+ SolverBase::solve(const SparseMatrix &A,
+ MPI::Vector &x,
+ const MPI::Vector &b,
const PreconditionBase &preconditioner)
{
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// Note: "A" is set as a constant reference so that all patterns for ::solve
// can be used by the inverse_operator of LinearOperator
void
- SolverBase::solve(const Epetra_Operator & A,
- MPI::Vector & x,
- const MPI::Vector & b,
+ SolverBase::solve(const Epetra_Operator &A,
+ MPI::Vector &x,
+ const MPI::Vector &b,
const PreconditionBase &preconditioner)
{
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// can be used by the inverse_operator of LinearOperator
void
SolverBase::solve(const Epetra_Operator &A,
- MPI::Vector & x,
- const MPI::Vector & b,
+ MPI::Vector &x,
+ const MPI::Vector &b,
const Epetra_Operator &preconditioner)
{
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// Note: "A" is set as a constant reference so that all patterns for ::solve
// can be used by the inverse_operator of LinearOperator
void
- SolverBase::solve(const Epetra_Operator & A,
- Epetra_MultiVector & x,
+ SolverBase::solve(const Epetra_Operator &A,
+ Epetra_MultiVector &x,
const Epetra_MultiVector &b,
- const PreconditionBase & preconditioner)
+ const PreconditionBase &preconditioner)
{
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// about the matrix and vectors.
// Note: "A" is set as a constant reference so that all patterns for ::solve
// can be used by the inverse_operator of LinearOperator
void
- SolverBase::solve(const Epetra_Operator & A,
- Epetra_MultiVector & x,
+ SolverBase::solve(const Epetra_Operator &A,
+ Epetra_MultiVector &x,
const Epetra_MultiVector &b,
- const Epetra_Operator & preconditioner)
+ const Epetra_Operator &preconditioner)
{
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// about the matrix and vectors.
void
- SolverBase::solve(const SparseMatrix & A,
- dealii::Vector<double> & x,
+ SolverBase::solve(const SparseMatrix &A,
+ dealii::Vector<double> &x,
const dealii::Vector<double> &b,
- const PreconditionBase & preconditioner)
+ const PreconditionBase &preconditioner)
{
// In case we call the solver with deal.II vectors, we create views of the
// vectors in Epetra format.
void
- SolverBase::solve(Epetra_Operator & A,
- dealii::Vector<double> & x,
+ SolverBase::solve(Epetra_Operator &A,
+ dealii::Vector<double> &x,
const dealii::Vector<double> &b,
- const PreconditionBase & preconditioner)
+ const PreconditionBase &preconditioner)
{
Epetra_Vector ep_x(View, A.OperatorDomainMap(), x.begin());
Epetra_Vector ep_b(View,
void
- SolverBase::solve(const SparseMatrix & A,
- dealii::LinearAlgebra::distributed::Vector<double> & x,
+ SolverBase::solve(const SparseMatrix &A,
+ dealii::LinearAlgebra::distributed::Vector<double> &x,
const dealii::LinearAlgebra::distributed::Vector<double> &b,
const PreconditionBase &preconditioner)
{
void
- SolverBase::solve(Epetra_Operator & A,
- dealii::LinearAlgebra::distributed::Vector<double> & x,
+ SolverBase::solve(Epetra_Operator &A,
+ dealii::LinearAlgebra::distributed::Vector<double> &x,
const dealii::LinearAlgebra::distributed::Vector<double> &b,
const PreconditionBase &preconditioner)
{
template <>
void
- SolverBase::set_preconditioner(AztecOO & solver,
+ SolverBase::set_preconditioner(AztecOO &solver,
const PreconditionBase &preconditioner)
{
// Introduce the preconditioner, if the identity preconditioner is used,
template <>
void
- SolverBase::set_preconditioner(AztecOO & solver,
+ SolverBase::set_preconditioner(AztecOO &solver,
const Epetra_Operator &preconditioner)
{
const int ierr =
void
SolverDirect::solve(
- dealii::LinearAlgebra::distributed::Vector<double> & x,
+ dealii::LinearAlgebra::distributed::Vector<double> &x,
const dealii::LinearAlgebra::distributed::Vector<double> &b)
{
Epetra_Vector ep_x(View,
void
SolverDirect::solve(const SparseMatrix &A,
- MPI::Vector & x,
- const MPI::Vector & b)
+ MPI::Vector &x,
+ const MPI::Vector &b)
{
// We need an Epetra_LinearProblem object to let the Amesos solver know
// about the matrix and vectors.
void
- SolverDirect::solve(const SparseMatrix & A,
- dealii::Vector<double> & x,
+ SolverDirect::solve(const SparseMatrix &A,
+ dealii::Vector<double> &x,
const dealii::Vector<double> &b)
{
// In case we call the solver with deal.II vectors, we create views of the
void
SolverDirect::solve(
- const SparseMatrix & A,
- dealii::LinearAlgebra::distributed::Vector<double> & x,
+ const SparseMatrix &A,
+ dealii::LinearAlgebra::distributed::Vector<double> &x,
const dealii::LinearAlgebra::distributed::Vector<double> &b)
{
AssertDimension(x.locally_owned_size(),
- SparseMatrix::SparseMatrix(const IndexSet & parallel_partitioning,
+ SparseMatrix::SparseMatrix(const IndexSet ¶llel_partitioning,
const MPI_Comm communicator,
const unsigned int n_max_entries_per_row)
: column_space_map(new Epetra_Map(
int n_entries, rhs_n_entries;
TrilinosScalar *value_ptr, *rhs_value_ptr;
- int * index_ptr, *rhs_index_ptr;
+ int *index_ptr, *rhs_index_ptr;
int ierr = rhs.matrix->ExtractMyRowView(row_local,
rhs_n_entries,
rhs_value_ptr,
template <typename SparsityPatternType>
void
- reinit_matrix(const IndexSet & row_parallel_partitioning,
- const IndexSet & column_parallel_partitioning,
- const SparsityPatternType & sparsity_pattern,
+ reinit_matrix(const IndexSet &row_parallel_partitioning,
+ const IndexSet &column_parallel_partitioning,
+ const SparsityPatternType &sparsity_pattern,
const bool exchange_data,
const MPI_Comm communicator,
std::unique_ptr<Epetra_Map> &column_space_map,
std::unique_ptr<Epetra_FECrsMatrix> &matrix,
- std::unique_ptr<Epetra_CrsMatrix> & nonlocal_matrix,
- std::unique_ptr<Epetra_Export> & nonlocal_matrix_exporter)
+ std::unique_ptr<Epetra_CrsMatrix> &nonlocal_matrix,
+ std::unique_ptr<Epetra_Export> &nonlocal_matrix_exporter)
{
// release memory before reallocation
matrix.reset();
{
public:
Epetra_CrsGraphMod(const Epetra_Map &row_map,
- const int * n_entries_per_row)
+ const int *n_entries_per_row)
: Epetra_CrsGraph(Copy, row_map, n_entries_per_row, true)
{}
// more information about the non-locally owned rows
template <>
void
- reinit_matrix(const IndexSet & row_parallel_partitioning,
- const IndexSet & column_parallel_partitioning,
+ reinit_matrix(const IndexSet &row_parallel_partitioning,
+ const IndexSet &column_parallel_partitioning,
const DynamicSparsityPattern &sparsity_pattern,
const bool exchange_data,
const MPI_Comm communicator,
- std::unique_ptr<Epetra_Map> & column_space_map,
+ std::unique_ptr<Epetra_Map> &column_space_map,
std::unique_ptr<Epetra_FECrsMatrix> &matrix,
- std::unique_ptr<Epetra_CrsMatrix> & nonlocal_matrix,
- std::unique_ptr<Epetra_Export> & nonlocal_matrix_exporter)
+ std::unique_ptr<Epetra_CrsMatrix> &nonlocal_matrix,
+ std::unique_ptr<Epetra_Export> &nonlocal_matrix_exporter)
{
matrix.reset();
nonlocal_matrix.reset();
template <typename SparsityPatternType>
inline std::enable_if_t<
!std::is_same_v<SparsityPatternType, dealii::SparseMatrix<double>>>
- SparseMatrix::reinit(const IndexSet & row_parallel_partitioning,
- const IndexSet & col_parallel_partitioning,
+ SparseMatrix::reinit(const IndexSet &row_parallel_partitioning,
+ const IndexSet &col_parallel_partitioning,
const SparsityPatternType &sparsity_pattern,
const MPI_Comm communicator,
const bool exchange_data)
template <typename number>
inline void
SparseMatrix::reinit(
- const IndexSet & row_parallel_partitioning,
- const IndexSet & col_parallel_partitioning,
+ const IndexSet &row_parallel_partitioning,
+ const IndexSet &col_parallel_partitioning,
const ::dealii::SparseMatrix<number> &dealii_sparse_matrix,
const MPI_Comm communicator,
const double drop_tolerance,
const bool copy_values,
- const ::dealii::SparsityPattern * use_this_sparsity)
+ const ::dealii::SparsityPattern *use_this_sparsity)
{
if (copy_values == false)
{
const ::dealii::SparseMatrix<number> &dealii_sparse_matrix,
const double drop_tolerance,
const bool copy_values,
- const ::dealii::SparsityPattern * use_this_sparsity)
+ const ::dealii::SparsityPattern *use_this_sparsity)
{
reinit(complete_index_set(dealii_sparse_matrix.m()),
complete_index_set(dealii_sparse_matrix.n()),
// point to the first data entry in the two
// matrices and copy the content
const TrilinosScalar *in_values = input_matrix[0];
- TrilinosScalar * values = (*matrix)[0];
+ TrilinosScalar *values = (*matrix)[0];
const size_type my_nonzeros = input_matrix.NumMyNonzeros();
std::memcpy(values, in_values, my_nonzeros * sizeof(TrilinosScalar));
}
if (local_row >= 0)
{
TrilinosScalar *values;
- int * col_indices;
+ int *col_indices;
int num_entries;
const int ierr =
matrix->ExtractMyRowView(local_row, num_entries, values, col_indices);
// of a view of the row.
int nnz_present = matrix->NumMyEntries(trilinos_i);
int nnz_extracted;
- int * col_indices;
+ int *col_indices;
TrilinosScalar *values;
// Generate the view and make
// of a view of the row.
int nnz_present = matrix->NumMyEntries(trilinos_i);
int nnz_extracted;
- int * col_indices;
+ int *col_indices;
TrilinosScalar *values;
// Generate the view and make
void
- SparseMatrix::set(const std::vector<size_type> & row_indices,
- const std::vector<size_type> & col_indices,
+ SparseMatrix::set(const std::vector<size_type> &row_indices,
+ const std::vector<size_type> &col_indices,
const FullMatrix<TrilinosScalar> &values,
const bool elide_zero_values)
{
void
SparseMatrix::set(const size_type row,
- const std::vector<size_type> & col_indices,
+ const std::vector<size_type> &col_indices,
const std::vector<TrilinosScalar> &values,
const bool elide_zero_values)
{
void
SparseMatrix::set<TrilinosScalar>(const size_type row,
const size_type n_cols,
- const size_type * col_indices,
+ const size_type *col_indices,
const TrilinosScalar *values,
const bool elide_zero_values)
{
last_action = Insert;
const TrilinosWrappers::types::int_type *col_index_ptr;
- const TrilinosScalar * col_value_ptr;
+ const TrilinosScalar *col_value_ptr;
const TrilinosWrappers::types::int_type trilinos_row = row;
TrilinosWrappers::types::int_type n_columns;
void
- SparseMatrix::add(const std::vector<size_type> & indices,
+ SparseMatrix::add(const std::vector<size_type> &indices,
const FullMatrix<TrilinosScalar> &values,
const bool elide_zero_values)
{
void
- SparseMatrix::add(const std::vector<size_type> & row_indices,
- const std::vector<size_type> & col_indices,
+ SparseMatrix::add(const std::vector<size_type> &row_indices,
+ const std::vector<size_type> &col_indices,
const FullMatrix<TrilinosScalar> &values,
const bool elide_zero_values)
{
void
SparseMatrix::add(const size_type row,
- const std::vector<size_type> & col_indices,
+ const std::vector<size_type> &col_indices,
const std::vector<TrilinosScalar> &values,
const bool elide_zero_values)
{
void
SparseMatrix::add(const size_type row,
const size_type n_cols,
- const size_type * col_indices,
+ const size_type *col_indices,
const TrilinosScalar *values,
const bool elide_zero_values,
const bool /*col_indices_are_sorted*/)
last_action = Add;
const TrilinosWrappers::types::int_type *col_index_ptr;
- const TrilinosScalar * col_value_ptr;
+ const TrilinosScalar *col_value_ptr;
const TrilinosWrappers::types::int_type trilinos_row = row;
TrilinosWrappers::types::int_type n_columns;
"")
<< " has the following indices:" << std::endl;
std::vector<TrilinosWrappers::types::int_type> indices;
- const Epetra_CrsGraph * graph =
+ const Epetra_CrsGraph *graph =
(nonlocal_matrix.get() != nullptr &&
matrix->RowMap().MyGID(
static_cast<TrilinosWrappers::types::int_type>(row)) == false) ?
// map.
int n_entries, rhs_n_entries;
TrilinosScalar *value_ptr, *rhs_value_ptr;
- int * index_ptr, *rhs_index_ptr;
+ int *index_ptr, *rhs_index_ptr;
int ierr = rhs.matrix->ExtractMyRowView(row_local,
rhs_n_entries,
rhs_value_ptr,
{}
inline void
- check_vector_map_equality(const Epetra_CrsMatrix & m,
+ check_vector_map_equality(const Epetra_CrsMatrix &m,
const TrilinosWrappers::MPI::Vector &in,
const TrilinosWrappers::MPI::Vector &out)
{
TrilinosScalar
- SparseMatrix::residual(MPI::Vector & dst,
+ SparseMatrix::residual(MPI::Vector &dst,
const MPI::Vector &x,
const MPI::Vector &b) const
{
void
perform_mmult(const SparseMatrix &inputleft,
const SparseMatrix &inputright,
- SparseMatrix & result,
- const MPI::Vector & V,
+ SparseMatrix &result,
+ const MPI::Vector &V,
const bool transpose_left)
{
const bool use_vector = (V.size() == inputright.m() ? true : false);
void
- SparseMatrix::mmult(SparseMatrix & C,
+ SparseMatrix::mmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V) const
+ const MPI::Vector &V) const
{
internals::perform_mmult(*this, B, C, V, false);
}
void
- SparseMatrix::Tmmult(SparseMatrix & C,
+ SparseMatrix::Tmmult(SparseMatrix &C,
const SparseMatrix &B,
- const MPI::Vector & V) const
+ const MPI::Vector &V) const
{
internals::perform_mmult(*this, B, C, V, true);
}
else
{
double *values;
- int * indices;
+ int *indices;
int num_entries;
for (int i = 0; i < matrix->NumMyRows(); ++i)
TrilinosPayload::TrilinosPayload(
- const TrilinosPayload & payload_exemplar,
+ const TrilinosPayload &payload_exemplar,
const TrilinosWrappers::SparseMatrix &matrix)
: TrilinosPayload(const_cast<Epetra_CrsMatrix &>(
TrilinosPayload::TrilinosPayload(
- const TrilinosWrappers::SparseMatrix & matrix_exemplar,
+ const TrilinosWrappers::SparseMatrix &matrix_exemplar,
const TrilinosWrappers::PreconditionBase &preconditioner)
: TrilinosPayload(preconditioner.trilinos_operator(),
/*op_supports_inverse_operations = */ true,
TrilinosPayload::TrilinosPayload(
- const TrilinosPayload & payload_exemplar,
+ const TrilinosPayload &payload_exemplar,
const TrilinosWrappers::PreconditionBase &preconditioner)
: TrilinosPayload(preconditioner.trilinos_operator(),
/*op_supports_inverse_operations = */ true,
TrilinosPayload return_op(first_op, second_op);
// Capture by copy so the payloads are always valid
- return_op.vmult = [first_op, second_op](Range & tril_dst,
+ return_op.vmult = [first_op, second_op](Range &tril_dst,
const Domain &tril_src) {
// Duplicated from LinearOperator::operator*
// TODO: Template the constructor on GrowingVectorMemory vector type?
AssertThrow(ierr == 0, ExcTrilinosError(ierr));
};
- return_op.Tvmult = [first_op, second_op](Domain & tril_dst,
+ return_op.Tvmult = [first_op, second_op](Domain &tril_dst,
const Range &tril_src) {
// Duplicated from LinearOperator::operator*
// TODO: Template the constructor on GrowingVectorMemory vector type?
const_cast<TrilinosPayload &>(second_op).transpose();
};
- return_op.inv_vmult = [first_op, second_op](Domain & tril_dst,
+ return_op.inv_vmult = [first_op, second_op](Domain &tril_dst,
const Range &tril_src) {
// Duplicated from LinearOperator::operator*
// TODO: Template the constructor on GrowingVectorMemory vector type?
AssertThrow(ierr == 0, ExcTrilinosError(ierr));
};
- return_op.inv_Tvmult = [first_op, second_op](Range & tril_dst,
+ return_op.inv_Tvmult = [first_op, second_op](Range &tril_dst,
const Domain &tril_src) {
// Duplicated from LinearOperator::operator*
// TODO: Template the constructor on GrowingVectorMemory vector type?
TrilinosPayload return_op(first_op, second_op);
// Capture by copy so the payloads are always valid
- return_op.vmult = [first_op, second_op](Range & tril_dst,
+ return_op.vmult = [first_op, second_op](Range &tril_dst,
const Domain &tril_src) {
// Duplicated from LinearOperator::operator*
// TODO: Template the constructor on GrowingVectorMemory vector type?
first_op.Apply(tril_int, tril_dst);
};
- return_op.Tvmult = [first_op, second_op](Domain & tril_dst,
+ return_op.Tvmult = [first_op, second_op](Domain &tril_dst,
const Range &tril_src) {
// Duplicated from LinearOperator::operator*
// TODO: Template the constructor on GrowingVectorMemory vector type?
const_cast<TrilinosPayload &>(second_op).transpose();
};
- return_op.inv_vmult = [first_op, second_op](Domain & tril_dst,
+ return_op.inv_vmult = [first_op, second_op](Domain &tril_dst,
const Range &tril_src) {
// Duplicated from LinearOperator::operator*
// TODO: Template the constructor on GrowingVectorMemory vector type?
second_op.ApplyInverse(tril_int, tril_dst);
};
- return_op.inv_Tvmult = [first_op, second_op](Range & tril_dst,
+ return_op.inv_Tvmult = [first_op, second_op](Range &tril_dst,
const Domain &tril_src) {
// Duplicated from LinearOperator::operator*
// TODO: Template the constructor on GrowingVectorMemory vector type?
SparsityPattern::SparsityPattern(
- const IndexSet & parallel_partitioning,
+ const IndexSet ¶llel_partitioning,
const MPI_Comm communicator,
const std::vector<size_type> &n_entries_per_row)
{
SparsityPattern::SparsityPattern(
- const IndexSet & row_parallel_partitioning,
- const IndexSet & col_parallel_partitioning,
+ const IndexSet &row_parallel_partitioning,
+ const IndexSet &col_parallel_partitioning,
const MPI_Comm communicator,
const std::vector<size_type> &n_entries_per_row)
{
using size_type = SparsityPattern::size_type;
void
- reinit_sp(const Epetra_Map & row_map,
- const Epetra_Map & col_map,
+ reinit_sp(const Epetra_Map &row_map,
+ const Epetra_Map &col_map,
const size_type n_entries_per_row,
- std::unique_ptr<Epetra_Map> & column_space_map,
+ std::unique_ptr<Epetra_Map> &column_space_map,
std::unique_ptr<Epetra_FECrsGraph> &graph,
- std::unique_ptr<Epetra_CrsGraph> & nonlocal_graph)
+ std::unique_ptr<Epetra_CrsGraph> &nonlocal_graph)
{
Assert(row_map.IsOneToOne(),
ExcMessage("Row map must be 1-to-1, i.e., no overlap between "
Copy, row_map, n_entries_per_row, false
// TODO: Check which new Trilinos version supports this...
// Remember to change tests/trilinos/assemble_matrix_parallel_07, too.
- //#if DEAL_II_TRILINOS_VERSION_GTE(11,14,0)
+ // #if DEAL_II_TRILINOS_VERSION_GTE(11,14,0)
// , true
- //#endif
+ // #endif
);
else
graph = std::make_unique<Epetra_FECrsGraph>(
void
- reinit_sp(const Epetra_Map & row_map,
- const Epetra_Map & col_map,
- const std::vector<size_type> & n_entries_per_row,
- std::unique_ptr<Epetra_Map> & column_space_map,
+ reinit_sp(const Epetra_Map &row_map,
+ const Epetra_Map &col_map,
+ const std::vector<size_type> &n_entries_per_row,
+ std::unique_ptr<Epetra_Map> &column_space_map,
std::unique_ptr<Epetra_FECrsGraph> &graph,
- std::unique_ptr<Epetra_CrsGraph> & nonlocal_graph)
+ std::unique_ptr<Epetra_CrsGraph> &nonlocal_graph)
{
Assert(row_map.IsOneToOne(),
ExcMessage("Row map must be 1-to-1, i.e., no overlap between "
Copy, row_map, local_entries_per_row.data(), false
// TODO: Check which new Trilinos version supports this...
// Remember to change tests/trilinos/assemble_matrix_parallel_07, too.
- //#if DEAL_II_TRILINOS_VERSION_GTE(11,14,0)
+ // #if DEAL_II_TRILINOS_VERSION_GTE(11,14,0)
// , true
- //#endif
+ // #endif
);
else
graph = std::make_unique<Epetra_FECrsGraph>(
template <typename SparsityPatternType>
void
- reinit_sp(const Epetra_Map & row_map,
- const Epetra_Map & col_map,
- const SparsityPatternType & sp,
+ reinit_sp(const Epetra_Map &row_map,
+ const Epetra_Map &col_map,
+ const SparsityPatternType &sp,
const bool exchange_data,
- std::unique_ptr<Epetra_Map> & column_space_map,
+ std::unique_ptr<Epetra_Map> &column_space_map,
std::unique_ptr<Epetra_FECrsGraph> &graph,
- std::unique_ptr<Epetra_CrsGraph> & nonlocal_graph)
+ std::unique_ptr<Epetra_CrsGraph> &nonlocal_graph)
{
nonlocal_graph.reset();
graph.reset();
void
- SparsityPattern::reinit(const IndexSet & parallel_partitioning,
+ SparsityPattern::reinit(const IndexSet ¶llel_partitioning,
const MPI_Comm communicator,
const std::vector<size_type> &n_entries_per_row)
{
template <typename SparsityPatternType>
void
SparsityPattern::reinit(
- const IndexSet & row_parallel_partitioning,
- const IndexSet & col_parallel_partitioning,
+ const IndexSet &row_parallel_partitioning,
+ const IndexSet &col_parallel_partitioning,
const SparsityPatternType &nontrilinos_sparsity_pattern,
const MPI_Comm communicator,
const bool exchange_data)
template <typename SparsityPatternType>
void
SparsityPattern::reinit(
- const IndexSet & parallel_partitioning,
+ const IndexSet ¶llel_partitioning,
const SparsityPatternType &nontrilinos_sparsity_pattern,
const MPI_Comm communicator,
const bool exchange_data)
void
- SparsityPattern::add_row_entries(const size_type & row,
+ SparsityPattern::add_row_entries(const size_type &row,
const ArrayView<const size_type> &columns,
const bool indices_are_sorted)
{
Vector::Vector(const IndexSet ¶llel_partitioner,
- const Vector & v,
+ const Vector &v,
const MPI_Comm communicator)
: Vector()
{
void
Vector::import_nonlocal_data_for_fe(const TrilinosWrappers::SparseMatrix &m,
- const Vector & v)
+ const Vector &v)
{
Assert(m.trilinos_matrix().Filled() == true,
ExcMessage("Matrix is not compressed. "
{
// get a representation of the vector and
// loop over all the elements
- TrilinosScalar * start_ptr = (*vector)[0];
+ TrilinosScalar *start_ptr = (*vector)[0];
const TrilinosScalar *ptr = start_ptr,
*eptr = start_ptr + vector->Map().NumMyElements();
unsigned int flag = 0;
{
// get a representation of the vector and
// loop over all the elements
- TrilinosScalar * start_ptr = (*vector)[0];
+ TrilinosScalar *start_ptr = (*vector)[0];
const TrilinosScalar *ptr = start_ptr,
*eptr = start_ptr + vector->Map().NumMyElements();
unsigned int flag = 0;
void
- Vector::print(std::ostream & out,
+ Vector::print(std::ostream &out,
const unsigned int precision,
const bool scientific,
const bool across) const
void
call_stev(const char jobz,
const types::blas_int n,
- Number * d,
- Number * e,
- Number * z,
+ Number *d,
+ Number *e,
+ Number *z,
const types::blas_int ldz,
- Number * work,
- types::blas_int * info)
+ Number *work,
+ types::blas_int *info)
{
stev(&jobz, &n, d, e, z, &ldz, work, info);
}
for (S1, S2 : REAL_SCALARS)
{
template bool Vector<S1>::operator==<S2>(const Vector<S2> &) const;
- template S1 Vector<S1>::operator*<S2>(const Vector<S2> &) const;
+ template S1 Vector<S1>::operator*<S2>(const Vector<S2> &) const;
}
for (S1, S2 : COMPLEX_SCALARS)
{
template bool Vector<S1>::operator==<S2>(const Vector<S2> &) const;
- template S1 Vector<S1>::operator*<S2>(const Vector<S2> &) const;
+ template S1 Vector<S1>::operator*<S2>(const Vector<S2> &) const;
}
for (S1 : COMPLEX_SCALARS; S2 : REAL_SCALARS)
void
DoFInfo::reorder_cells(
- const TaskInfo & task_info,
- const std::vector<unsigned int> & renumbering,
- const std::vector<unsigned int> & constraint_pool_row_index,
+ const TaskInfo &task_info,
+ const std::vector<unsigned int> &renumbering,
+ const std::vector<unsigned int> &constraint_pool_row_index,
const std::vector<unsigned char> &irregular_cells)
{
(void)constraint_pool_row_index;
void
DoFInfo::compute_tight_partitioners(
- const Table<2, ShapeInfo<double>> & shape_info,
+ const Table<2, ShapeInfo<double>> &shape_info,
const unsigned int n_owned_cells,
const unsigned int n_lanes,
const std::vector<FaceToCellTopology<1>> &inner_faces,
void
compute_row_lengths(const unsigned int begin,
const unsigned int end,
- const DoFInfo & dof_info,
- std::vector<std::mutex> & mutexes,
+ const DoFInfo &dof_info,
+ std::vector<std::mutex> &mutexes,
std::vector<unsigned int> &row_lengths)
{
std::vector<unsigned int> scratch;
void
fill_connectivity_dofs(const unsigned int begin,
const unsigned int end,
- const DoFInfo & dof_info,
+ const DoFInfo &dof_info,
const std::vector<unsigned int> &row_lengths,
- std::vector<std::mutex> & mutexes,
- dealii::SparsityPattern & connectivity_dof)
+ std::vector<std::mutex> &mutexes,
+ dealii::SparsityPattern &connectivity_dof)
{
std::vector<unsigned int> scratch;
const unsigned int n_components = dof_info.start_components.back();
void
fill_connectivity(const unsigned int begin,
const unsigned int end,
- const DoFInfo & dof_info,
+ const DoFInfo &dof_info,
const std::vector<unsigned int> &renumbering,
- const dealii::SparsityPattern & connectivity_dof,
- DynamicSparsityPattern & connectivity)
+ const dealii::SparsityPattern &connectivity_dof,
+ DynamicSparsityPattern &connectivity)
{
ordered_vector row_entries;
const unsigned int n_components = dof_info.start_components.back();
void
DoFInfo::make_connectivity_graph(
- const TaskInfo & task_info,
+ const TaskInfo &task_info,
const std::vector<unsigned int> &renumbering,
- DynamicSparsityPattern & connectivity) const
+ DynamicSparsityPattern &connectivity) const
{
unsigned int n_rows = (vector_partitioner->local_range().second -
vector_partitioner->local_range().first) +
public:
ActualCellWork(MFWorkerInterface **worker_pointer,
const unsigned int partition,
- const TaskInfo & task_info)
+ const TaskInfo &task_info)
: worker(nullptr)
, worker_pointer(worker_pointer)
, partition(partition)
ActualCellWork(MFWorkerInterface &worker,
const unsigned int partition,
- const TaskInfo & task_info)
+ const TaskInfo &task_info)
: worker(&worker)
, worker_pointer(nullptr)
, partition(partition)
}
private:
- MFWorkerInterface * worker;
+ MFWorkerInterface *worker;
MFWorkerInterface **worker_pointer;
const unsigned int partition;
- const TaskInfo & task_info;
+ const TaskInfo &task_info;
};
class CellWork : public tbb::task
public:
CellWork(MFWorkerInterface &worker,
const unsigned int partition,
- const TaskInfo & task_info,
+ const TaskInfo &task_info,
const bool is_blocked)
: dummy(nullptr)
, work(worker, partition, task_info)
public:
PartitionWork(MFWorkerInterface &function_in,
const unsigned int partition_in,
- const TaskInfo & task_info_in,
+ const TaskInfo &task_info_in,
const bool is_blocked_in = false)
: dummy(nullptr)
, function(function_in)
private:
MFWorkerInterface &function;
const unsigned int partition;
- const TaskInfo & task_info;
+ const TaskInfo &task_info;
const bool is_blocked;
};
{
public:
CellWork(MFWorkerInterface &worker_in,
- const TaskInfo & task_info_in,
+ const TaskInfo &task_info_in,
const unsigned int partition_in)
: worker(worker_in)
, task_info(task_info_in)
private:
MFWorkerInterface &worker;
- const TaskInfo & task_info;
+ const TaskInfo &task_info;
const unsigned int partition;
};
public:
PartitionWork(MFWorkerInterface &worker_in,
const unsigned int partition_in,
- const TaskInfo & task_info_in,
+ const TaskInfo &task_info_in,
const bool is_blocked_in)
: dummy(nullptr)
, worker(worker_in)
private:
MFWorkerInterface &worker;
const unsigned int partition;
- const TaskInfo & task_info;
+ const TaskInfo &task_info;
const bool is_blocked;
};
template <typename StreamType>
void
- TaskInfo::print_memory_statistics(StreamType & out,
+ TaskInfo::print_memory_statistics(StreamType &out,
const std::size_t data_length) const
{
Utilities::MPI::MinMaxAvg memory_c =
const std::vector<unsigned int> &cell_vectorization_categories,
const bool cell_vectorization_categories_strict,
const std::vector<unsigned int> &parent_relation,
- std::vector<unsigned int> & renumbering,
- std::vector<unsigned char> & incompletely_filled_vectorization)
+ std::vector<unsigned int> &renumbering,
+ std::vector<unsigned char> &incompletely_filled_vectorization)
{
Assert(dofs_per_cell > 0, ExcInternalError());
// This function is decomposed into several steps to determine a good
void
TaskInfo::initial_setup_blocks_tasks(
const std::vector<unsigned int> &boundary_cells,
- std::vector<unsigned int> & renumbering,
- std::vector<unsigned char> & incompletely_filled_vectorization)
+ std::vector<unsigned int> &renumbering,
+ std::vector<unsigned char> &incompletely_filled_vectorization)
{
const unsigned int n_cell_batches =
(n_active_cells + vectorization_length - 1) / vectorization_length;
void
TaskInfo::make_thread_graph_partition_color(
- DynamicSparsityPattern & connectivity_large,
- std::vector<unsigned int> & renumbering,
+ DynamicSparsityPattern &connectivity_large,
+ std::vector<unsigned int> &renumbering,
std::vector<unsigned char> &irregular_cells,
const bool)
{
void
TaskInfo::make_thread_graph(
const std::vector<unsigned int> &cell_active_fe_index,
- DynamicSparsityPattern & connectivity,
- std::vector<unsigned int> & renumbering,
- std::vector<unsigned char> & irregular_cells,
+ DynamicSparsityPattern &connectivity,
+ std::vector<unsigned int> &renumbering,
+ std::vector<unsigned char> &irregular_cells,
const bool hp_bool)
{
const unsigned int n_cell_batches = *(cell_partition_data.end() - 2);
void
TaskInfo::make_thread_graph_partition_partition(
const std::vector<unsigned int> &cell_active_fe_index,
- DynamicSparsityPattern & connectivity,
- std::vector<unsigned int> & renumbering,
- std::vector<unsigned char> & irregular_cells,
+ DynamicSparsityPattern &connectivity,
+ std::vector<unsigned int> &renumbering,
+ std::vector<unsigned char> &irregular_cells,
const bool hp_bool)
{
const unsigned int n_cell_batches = *(cell_partition_data.end() - 2);
void
TaskInfo::make_connectivity_cells_to_blocks(
const std::vector<unsigned char> &irregular_cells,
- const DynamicSparsityPattern & connectivity_cells,
- DynamicSparsityPattern & connectivity_blocks) const
+ const DynamicSparsityPattern &connectivity_cells,
+ DynamicSparsityPattern &connectivity_blocks) const
{
std::vector<std::vector<unsigned int>> cell_blocks(n_blocks);
std::vector<unsigned int> touched_cells(n_active_cells);
// partition. Version without preblocking.
void
TaskInfo::make_partitioning_within_partitions_post_blocked(
- const DynamicSparsityPattern & connectivity,
+ const DynamicSparsityPattern &connectivity,
const std::vector<unsigned int> &cell_active_fe_index,
const unsigned int partition,
const unsigned int cluster_size,
const std::vector<unsigned int> &cell_partition,
const std::vector<unsigned int> &partition_list,
const std::vector<unsigned int> &partition_size,
- std::vector<unsigned int> & partition_partition_list,
- std::vector<unsigned char> & irregular_cells)
+ std::vector<unsigned int> &partition_partition_list,
+ std::vector<unsigned char> &irregular_cells)
{
const unsigned int n_cell_batches = *(cell_partition_data.end() - 2);
const unsigned int n_ghost_slots =
// Version assumes preblocking.
void
TaskInfo::make_coloring_within_partitions_pre_blocked(
- const DynamicSparsityPattern & connectivity,
+ const DynamicSparsityPattern &connectivity,
const unsigned int partition,
const std::vector<unsigned int> &cell_partition,
const std::vector<unsigned int> &partition_list,
const std::vector<unsigned int> &partition_size,
- std::vector<unsigned int> & partition_color_list)
+ std::vector<unsigned int> &partition_color_list)
{
const unsigned int n_cell_batches = *(cell_partition_data.end() - 2);
std::vector<unsigned int> cell_color(n_blocks, n_cell_batches);
void
TaskInfo::make_partitioning(const DynamicSparsityPattern &connectivity,
const unsigned int cluster_size,
- std::vector<unsigned int> & cell_partition,
- std::vector<unsigned int> & partition_list,
- std::vector<unsigned int> & partition_size,
- unsigned int & partition) const
+ std::vector<unsigned int> &cell_partition,
+ std::vector<unsigned int> &partition_list,
+ std::vector<unsigned int> &partition_size,
+ unsigned int &partition) const
{
// For each block of cells, this variable saves to which partitions the
void
PartitionerWrapper::export_to_ghosted_array_start(
const unsigned int communication_channel,
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<double> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<double> &ghost_array,
+ const ArrayView<double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
(void)shared_arrays;
#ifndef DEAL_II_WITH_MPI
void
PartitionerWrapper::export_to_ghosted_array_finish(
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<double> &ghost_array,
+ std::vector<MPI_Request> &requests) const
{
(void)locally_owned_array;
(void)shared_arrays;
PartitionerWrapper::import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<double> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<double> &ghost_array,
+ const ArrayView<double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
(void)locally_owned_array;
(void)shared_arrays;
void
PartitionerWrapper::import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
- const ArrayView<double> & locally_owned_storage,
+ const ArrayView<double> &locally_owned_storage,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<const double> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<double> &ghost_array,
+ const ArrayView<const double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
(void)shared_arrays;
#ifndef DEAL_II_WITH_MPI
void
PartitionerWrapper::export_to_ghosted_array_start(
const unsigned int communication_channel,
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<float> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<float> &ghost_array,
+ const ArrayView<float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
(void)shared_arrays;
#ifndef DEAL_II_WITH_MPI
void
PartitionerWrapper::export_to_ghosted_array_finish(
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<float> &ghost_array,
+ std::vector<MPI_Request> &requests) const
{
(void)locally_owned_array;
(void)shared_arrays;
PartitionerWrapper::import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<float> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<float> &ghost_array,
+ const ArrayView<float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
(void)locally_owned_array;
(void)shared_arrays;
void
PartitionerWrapper::import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
- const ArrayView<float> & locally_owned_storage,
+ const ArrayView<float> &locally_owned_storage,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<const float> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<float> &ghost_array,
+ const ArrayView<const float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
(void)shared_arrays;
#ifndef DEAL_II_WITH_MPI
void
Full::export_to_ghosted_array_start(
const unsigned int communication_channel,
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<double> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<double> &ghost_array,
+ const ArrayView<double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
export_to_ghosted_array_start_impl(communication_channel,
locally_owned_array,
void
Full::export_to_ghosted_array_finish(
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<double> &ghost_array,
+ std::vector<MPI_Request> &requests) const
{
export_to_ghosted_array_finish_impl(locally_owned_array,
shared_arrays,
Full::import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<const double> & locally_owned_array,
+ const ArrayView<const double> &locally_owned_array,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<double> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<double> &ghost_array,
+ const ArrayView<double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
import_from_ghosted_array_start_impl(vector_operation,
communication_channel,
void
Full::import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
- const ArrayView<double> & locally_owned_storage,
+ const ArrayView<double> &locally_owned_storage,
const std::vector<ArrayView<const double>> &shared_arrays,
- const ArrayView<double> & ghost_array,
- const ArrayView<const double> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<double> &ghost_array,
+ const ArrayView<const double> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
import_from_ghosted_array_finish_impl(vector_operation,
locally_owned_storage,
void
Full::export_to_ghosted_array_start(
const unsigned int communication_channel,
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<float> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<float> &ghost_array,
+ const ArrayView<float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
export_to_ghosted_array_start_impl(communication_channel,
locally_owned_array,
void
Full::export_to_ghosted_array_finish(
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<float> &ghost_array,
+ std::vector<MPI_Request> &requests) const
{
export_to_ghosted_array_finish_impl(locally_owned_array,
shared_arrays,
Full::import_from_ghosted_array_start(
const VectorOperation::values vector_operation,
const unsigned int communication_channel,
- const ArrayView<const float> & locally_owned_array,
+ const ArrayView<const float> &locally_owned_array,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<float> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<float> &ghost_array,
+ const ArrayView<float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
import_from_ghosted_array_start_impl(vector_operation,
communication_channel,
void
Full::import_from_ghosted_array_finish(
const VectorOperation::values vector_operation,
- const ArrayView<float> & locally_owned_storage,
+ const ArrayView<float> &locally_owned_storage,
const std::vector<ArrayView<const float>> &shared_arrays,
- const ArrayView<float> & ghost_array,
- const ArrayView<const float> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<float> &ghost_array,
+ const ArrayView<const float> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
import_from_ghosted_array_finish_impl(vector_operation,
locally_owned_storage,
void
Full::export_to_ghosted_array_start_impl(
const unsigned int communication_channel,
- const ArrayView<const Number> & data_this,
+ const ArrayView<const Number> &data_this,
const std::vector<ArrayView<const Number>> &data_others,
- const ArrayView<Number> & buffer,
- const ArrayView<Number> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number> &buffer,
+ const ArrayView<Number> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
#ifndef DEAL_II_WITH_MPI
Assert(false, ExcNeedsMPI());
template <typename Number>
void
Full::export_to_ghosted_array_finish_impl(
- const ArrayView<const Number> & data_this,
+ const ArrayView<const Number> &data_this,
const std::vector<ArrayView<const Number>> &data_others,
- const ArrayView<Number> & ghost_array,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number> &ghost_array,
+ std::vector<MPI_Request> &requests) const
{
(void)data_this;
Full::import_from_ghosted_array_start_impl(
const VectorOperation::values operation,
const unsigned int communication_channel,
- const ArrayView<const Number> & data_this,
+ const ArrayView<const Number> &data_this,
const std::vector<ArrayView<const Number>> &data_others,
- const ArrayView<Number> & buffer,
- const ArrayView<Number> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number> &buffer,
+ const ArrayView<Number> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
(void)data_this;
const int ierr =
MPI_Irecv(temporary_storage.data() + import_targets_data[i][1],
import_targets_data[i][2],
- Utilities::MPI::mpi_type_id_for_type<decltype(
- *temporary_storage.data())>,
+ Utilities::MPI::mpi_type_id_for_type<
+ decltype(*temporary_storage.data())>,
import_targets_data[i][0],
communication_channel + 0,
comm,
void
Full::import_from_ghosted_array_finish_impl(
const VectorOperation::values operation,
- const ArrayView<Number> & data_this,
+ const ArrayView<Number> &data_this,
const std::vector<ArrayView<const Number>> &data_others,
- const ArrayView<Number> & buffer,
- const ArrayView<const Number> & temporary_storage,
- std::vector<MPI_Request> & requests) const
+ const ArrayView<Number> &buffer,
+ const ArrayView<const Number> &temporary_storage,
+ std::vector<MPI_Request> &requests) const
{
#ifndef DEAL_II_WITH_MPI
Assert(false, ExcNeedsMPI());
{
template <int dim, int spacedim>
ScratchData<dim, spacedim>::ScratchData(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- const UpdateFlags & update_flags,
- const Quadrature<dim - 1> & face_quadrature,
- const UpdateFlags & face_update_flags)
+ const Quadrature<dim> &quadrature,
+ const UpdateFlags &update_flags,
+ const Quadrature<dim - 1> &face_quadrature,
+ const UpdateFlags &face_update_flags)
: mapping(&mapping)
, fe(&fe)
, cell_quadrature(quadrature)
template <int dim, int spacedim>
ScratchData<dim, spacedim>::ScratchData(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- const UpdateFlags & update_flags,
- const UpdateFlags & neighbor_update_flags,
- const Quadrature<dim - 1> & face_quadrature,
- const UpdateFlags & face_update_flags,
- const UpdateFlags & neighbor_face_update_flags)
+ const Quadrature<dim> &quadrature,
+ const UpdateFlags &update_flags,
+ const UpdateFlags &neighbor_update_flags,
+ const Quadrature<dim - 1> &face_quadrature,
+ const UpdateFlags &face_update_flags,
+ const UpdateFlags &neighbor_face_update_flags)
: mapping(&mapping)
, fe(&fe)
, cell_quadrature(quadrature)
template <int dim, int spacedim>
ScratchData<dim, spacedim>::ScratchData(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- const UpdateFlags & update_flags,
- const Quadrature<dim - 1> & face_quadrature,
- const UpdateFlags & face_update_flags)
+ const Quadrature<dim> &quadrature,
+ const UpdateFlags &update_flags,
+ const Quadrature<dim - 1> &face_quadrature,
+ const UpdateFlags &face_update_flags)
: ScratchData(fe.reference_cell()
.template get_default_linear_mapping<dim, spacedim>(),
fe,
template <int dim, int spacedim>
ScratchData<dim, spacedim>::ScratchData(
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quadrature,
- const UpdateFlags & update_flags,
- const UpdateFlags & neighbor_update_flags,
- const Quadrature<dim - 1> & face_quadrature,
- const UpdateFlags & face_update_flags,
- const UpdateFlags & neighbor_face_update_flags)
+ const Quadrature<dim> &quadrature,
+ const UpdateFlags &update_flags,
+ const UpdateFlags &neighbor_update_flags,
+ const Quadrature<dim - 1> &face_quadrature,
+ const UpdateFlags &face_update_flags,
+ const UpdateFlags &neighbor_face_update_flags)
: ScratchData(fe.reference_cell()
.template get_default_linear_mapping<dim, spacedim>(),
fe,
template <int dim, int spacedim>
ScratchData<dim, spacedim>::ScratchData(
const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const hp::FECollection<dim, spacedim> & fe_collection,
- const hp::QCollection<dim> & cell_quadrature_collection,
- const UpdateFlags & cell_update_flags,
- const hp::QCollection<dim - 1> & face_quadrature_collection,
- const UpdateFlags & face_update_flags)
+ const hp::FECollection<dim, spacedim> &fe_collection,
+ const hp::QCollection<dim> &cell_quadrature_collection,
+ const UpdateFlags &cell_update_flags,
+ const hp::QCollection<dim - 1> &face_quadrature_collection,
+ const UpdateFlags &face_update_flags)
: mapping_collection(&mapping_collection)
, fe_collection(&fe_collection)
, cell_quadrature_collection(cell_quadrature_collection)
template <int dim, int spacedim>
ScratchData<dim, spacedim>::ScratchData(
const hp::MappingCollection<dim, spacedim> &mapping_collection,
- const hp::FECollection<dim, spacedim> & fe_collection,
- const hp::QCollection<dim> & cell_quadrature_collection,
- const UpdateFlags & cell_update_flags,
- const UpdateFlags & neighbor_cell_update_flags,
- const hp::QCollection<dim - 1> & face_quadrature_collection,
- const UpdateFlags & face_update_flags,
- const UpdateFlags & neighbor_face_update_flags)
+ const hp::FECollection<dim, spacedim> &fe_collection,
+ const hp::QCollection<dim> &cell_quadrature_collection,
+ const UpdateFlags &cell_update_flags,
+ const UpdateFlags &neighbor_cell_update_flags,
+ const hp::QCollection<dim - 1> &face_quadrature_collection,
+ const UpdateFlags &face_update_flags,
+ const UpdateFlags &neighbor_face_update_flags)
: mapping_collection(&mapping_collection)
, fe_collection(&fe_collection)
, cell_quadrature_collection(cell_quadrature_collection)
template <int dim, int spacedim>
ScratchData<dim, spacedim>::ScratchData(
const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & cell_quadrature_collection,
- const UpdateFlags & cell_update_flags,
- const hp::QCollection<dim - 1> & face_quadrature_collection,
- const UpdateFlags & face_update_flags)
+ const hp::QCollection<dim> &cell_quadrature_collection,
+ const UpdateFlags &cell_update_flags,
+ const hp::QCollection<dim - 1> &face_quadrature_collection,
+ const UpdateFlags &face_update_flags)
: ScratchData(fe_collection.get_reference_cell_default_linear_mapping(),
fe_collection,
cell_quadrature_collection,
template <int dim, int spacedim>
ScratchData<dim, spacedim>::ScratchData(
const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & cell_quadrature_collection,
- const UpdateFlags & cell_update_flags,
- const UpdateFlags & neighbor_cell_update_flags,
- const hp::QCollection<dim - 1> & face_quadrature_collection,
- const UpdateFlags & face_update_flags,
- const UpdateFlags & neighbor_face_update_flags)
+ const hp::QCollection<dim> &cell_quadrature_collection,
+ const UpdateFlags &cell_update_flags,
+ const UpdateFlags &neighbor_cell_update_flags,
+ const hp::QCollection<dim - 1> &face_quadrature_collection,
+ const UpdateFlags &face_update_flags,
+ const UpdateFlags &neighbor_face_update_flags)
: ScratchData(fe_collection.get_reference_cell_default_linear_mapping(),
fe_collection,
cell_quadrature_collection,
ScratchData<dim, spacedim>::reinit(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & neighbor_cell,
+ &neighbor_cell,
const unsigned int face_no)
{
Assert(hp_capability_enabled, ExcOnlyAvailableWithHP());
ScratchData<dim, spacedim>::reinit(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & neighbor_cell,
+ &neighbor_cell,
const unsigned int face_no,
const unsigned int subface_no)
{
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const unsigned int face_no,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & cell_neighbor,
+ &cell_neighbor,
const unsigned int face_no_neighbor)
{
return reinit(cell,
const unsigned int face_no,
const unsigned int sub_face_no,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & cell_neighbor,
+ &cell_neighbor,
const unsigned int face_no_neighbor,
const unsigned int sub_face_no_neighbor)
{
ScratchData<dim, spacedim>::reinit_neighbor(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & neighbor_cell,
+ &neighbor_cell,
const unsigned int face_no)
{
Assert(hp_capability_enabled, ExcOnlyAvailableWithHP());
ScratchData<dim, spacedim>::reinit_neighbor(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const typename DoFHandler<dim, spacedim>::active_cell_iterator
- & neighbor_cell,
+ &neighbor_cell,
const unsigned int face_no,
const unsigned int subface_no)
{
template <typename VectorType>
void
MGSmootherBase<VectorType>::apply(const unsigned int level,
- VectorType & u,
- const VectorType & rhs) const
+ VectorType &u,
+ const VectorType &rhs) const
{
u = typename VectorType::value_type(0.);
smooth(level, u, rhs);
template <typename VectorType>
void
MGTransferBase<VectorType>::prolongate_and_add(const unsigned int to_level,
- VectorType & dst,
- const VectorType & src) const
+ VectorType &dst,
+ const VectorType &src) const
{
VectorType temp;
temp.reinit(dst, true);
template <int dim, int spacedim, typename Number>
void
fill_internal(
- const DoFHandler<dim, spacedim> & mg_dof,
+ const DoFHandler<dim, spacedim> &mg_dof,
SmartPointer<const MGConstrainedDoFs> mg_constrained_dofs,
const MPI_Comm mpi_communicator,
const bool transfer_solution_vectors,
- std::vector<Table<2, unsigned int>> & copy_indices,
- std::vector<Table<2, unsigned int>> & copy_indices_global_mine,
- std::vector<Table<2, unsigned int>> & copy_indices_level_mine,
+ std::vector<Table<2, unsigned int>> ©_indices,
+ std::vector<Table<2, unsigned int>> ©_indices_global_mine,
+ std::vector<Table<2, unsigned int>> ©_indices_level_mine,
LinearAlgebra::distributed::Vector<Number> &ghosted_global_vector,
MGLevelObject<LinearAlgebra::distributed::Vector<Number>>
&ghosted_level_vector)
auto translate_indices =
[&](const std::vector<
std::pair<types::global_dof_index, types::global_dof_index>>
- & global_copy_indices,
+ &global_copy_indices,
Table<2, unsigned int> &local_copy_indices) {
local_copy_indices.reinit(2, global_copy_indices.size());
for (unsigned int i = 0; i < global_copy_indices.size(); ++i)
void
compute_row_length_vector(const DoFHandler<dim, spacedim> &dofs,
const unsigned int level,
- std::vector<unsigned int> & row_lengths,
+ std::vector<unsigned int> &row_lengths,
const DoFTools::Coupling flux_coupling)
{
Assert(row_lengths.size() == dofs.n_dofs(),
// This is the template for 2d and 3d. See version for 1d above
template <int dim, int spacedim>
void
- compute_row_length_vector(const DoFHandler<dim, spacedim> & dofs,
+ compute_row_length_vector(const DoFHandler<dim, spacedim> &dofs,
const unsigned int level,
- std::vector<unsigned int> & row_lengths,
+ std::vector<unsigned int> &row_lengths,
const Table<2, DoFTools::Coupling> &couplings,
const Table<2, DoFTools::Coupling> &flux_couplings)
{
template <int dim, int spacedim, typename number>
void
make_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const unsigned int level,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs)
template <int dim, int spacedim, typename number>
void
make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const unsigned int level,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs)
template <int dim, int spacedim>
void
make_flux_sparsity_pattern_edge(const DoFHandler<dim, spacedim> &dof,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const unsigned int level)
{
Assert((level >= 1) && (level < dof.get_triangulation().n_global_levels()),
template <int dim, int spacedim>
void
- make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> & dof,
- SparsityPatternBase & sparsity,
+ make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
+ SparsityPatternBase &sparsity,
const unsigned int level,
const Table<2, DoFTools::Coupling> &int_mask,
const Table<2, DoFTools::Coupling> &flux_mask)
{
- const FiniteElement<dim> & fe = dof.get_fe();
+ const FiniteElement<dim> &fe = dof.get_fe();
const types::global_dof_index n_dofs = dof.n_dofs(level);
const unsigned int n_comp = fe.n_components();
(void)n_dofs;
template <int dim, int spacedim>
void
- make_flux_sparsity_pattern_edge(const DoFHandler<dim, spacedim> & dof,
- SparsityPatternBase & sparsity,
+ make_flux_sparsity_pattern_edge(const DoFHandler<dim, spacedim> &dof,
+ SparsityPatternBase &sparsity,
const unsigned int level,
const Table<2, DoFTools::Coupling> &flux_mask)
{
void
make_interface_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
const MGConstrainedDoFs &mg_constrained_dofs,
- SparsityPatternBase & sparsity,
+ SparsityPatternBase &sparsity,
const unsigned int level)
{
const types::global_dof_index n_dofs = dof.n_dofs(level);
template <int dim, int spacedim>
void
count_dofs_per_component(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
std::vector<std::vector<types::global_dof_index>> &result,
bool only_once,
std::vector<unsigned int> target_component)
template <int dim, int spacedim>
void
count_dofs_per_block(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
std::vector<std::vector<types::global_dof_index>> &dofs_per_block,
std::vector<unsigned int> target_block)
{
make_boundary_list(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim> *>
- & function_map,
+ &function_map,
std::vector<std::set<types::global_dof_index>> &boundary_indices,
- const ComponentMask & component_mask)
+ const ComponentMask &component_mask)
{
Assert(boundary_indices.size() == dof.get_triangulation().n_global_levels(),
ExcDimensionMismatch(boundary_indices.size(),
template <int dim, int spacedim>
void
- make_boundary_list(const DoFHandler<dim, spacedim> & dof,
+ make_boundary_list(const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id,
const Function<spacedim> *> &function_map,
std::vector<IndexSet> &boundary_indices,
- const ComponentMask & component_mask)
+ const ComponentMask &component_mask)
{
Assert(boundary_indices.size() == dof.get_triangulation().n_global_levels(),
ExcDimensionMismatch(boundary_indices.size(),
template <int dim, int spacedim>
void
- make_boundary_list(const DoFHandler<dim, spacedim> & dof,
+ make_boundary_list(const DoFHandler<dim, spacedim> &dof,
const std::set<types::boundary_id> &boundary_ids,
- std::vector<IndexSet> & boundary_indices,
- const ComponentMask & component_mask)
+ std::vector<IndexSet> &boundary_indices,
+ const ComponentMask &component_mask)
{
boundary_indices.resize(dof.get_triangulation().n_global_levels());
template <int dim, int spacedim>
void
extract_inner_interface_dofs(const DoFHandler<dim, spacedim> &mg_dof_handler,
- std::vector<IndexSet> & interface_dofs)
+ std::vector<IndexSet> &interface_dofs)
{
Assert(interface_dofs.size() ==
mg_dof_handler.get_triangulation().n_global_levels(),
template void
extract_inner_interface_dofs(
const DoFHandler<deal_II_dimension> &mg_dof_handler,
- std::vector<IndexSet> & interface_dofs);
+ std::vector<IndexSet> &interface_dofs);
#if deal_II_dimension < 3
template void
template <int dim, typename number, int spacedim>
void
reinit_vector_by_blocks(
- const DoFHandler<dim, spacedim> & dof_handler,
- MGLevelObject<BlockVector<number>> & v,
- const std::vector<bool> & sel,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ MGLevelObject<BlockVector<number>> &v,
+ const std::vector<bool> &sel,
std::vector<std::vector<types::global_dof_index>> &ndofs)
{
std::vector<bool> selected = sel;
template <int dim, typename number, int spacedim>
void
reinit_vector_by_blocks(
- const DoFHandler<dim, spacedim> & dof_handler,
- MGLevelObject<dealii::Vector<number>> & v,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ MGLevelObject<dealii::Vector<number>> &v,
const unsigned int selected_block,
std::vector<std::vector<types::global_dof_index>> &ndofs)
{
void
MGTransferBlockSelect<number>::copy_to_mg(
const DoFHandler<dim, spacedim> &dof_handler,
- MGLevelObject<Vector<number>> & dst,
- const BlockVector<number2> & src) const
+ MGLevelObject<Vector<number>> &dst,
+ const BlockVector<number2> &src) const
{
reinit_vector_by_blocks(dof_handler, dst, selected_block, sizes);
// For MGTransferBlockSelect, the
void
MGTransferBlockSelect<number>::copy_to_mg(
const DoFHandler<dim, spacedim> &dof_handler,
- MGLevelObject<Vector<number>> & dst,
- const Vector<number2> & src) const
+ MGLevelObject<Vector<number>> &dst,
+ const Vector<number2> &src) const
{
reinit_vector_by_blocks(dof_handler, dst, selected_block, sizes);
// For MGTransferBlockSelect, the
template <int dim, typename number2, int spacedim>
void
MGTransferBlock<number>::copy_to_mg(
- const DoFHandler<dim, spacedim> & dof_handler,
+ const DoFHandler<dim, spacedim> &dof_handler,
MGLevelObject<BlockVector<number>> &dst,
- const BlockVector<number2> & src) const
+ const BlockVector<number2> &src) const
{
reinit_vector_by_blocks(dof_handler, dst, selected, sizes);
for (unsigned int level = dof_handler.get_triangulation().n_levels();
template <int dim, int spacedim>
void
MGTransferBlock<number>::build(const DoFHandler<dim, spacedim> &dof_handler,
- const std::vector<bool> & sel)
+ const std::vector<bool> &sel)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
unsigned int n_blocks = dof_handler.get_fe().n_blocks();
template <int dim, typename number, int spacedim>
void
reinit_vector_by_components(
- const DoFHandler<dim, spacedim> & mg_dof,
- MGLevelObject<BlockVector<number>> & v,
- const std::vector<bool> & sel,
- const std::vector<unsigned int> & target_comp,
+ const DoFHandler<dim, spacedim> &mg_dof,
+ MGLevelObject<BlockVector<number>> &v,
+ const std::vector<bool> &sel,
+ const std::vector<unsigned int> &target_comp,
std::vector<std::vector<types::global_dof_index>> &ndofs)
{
std::vector<bool> selected = sel;
template <int dim, typename number, int spacedim>
void
reinit_vector_by_components(
- const DoFHandler<dim, spacedim> & mg_dof,
- MGLevelObject<dealii::Vector<number>> & v,
- const ComponentMask & component_mask,
- const std::vector<unsigned int> & target_component,
+ const DoFHandler<dim, spacedim> &mg_dof,
+ MGLevelObject<dealii::Vector<number>> &v,
+ const ComponentMask &component_mask,
+ const std::vector<unsigned int> &target_component,
std::vector<std::vector<types::global_dof_index>> &ndofs)
{
Assert(component_mask.represents_n_components(target_component.size()),
void
MGTransferSelect<number>::do_copy_to_mg(
const DoFHandler<dim, spacedim> &mg_dof_handler,
- MGLevelObject<Vector<number>> & dst,
- const InVector & src) const
+ MGLevelObject<Vector<number>> &dst,
+ const InVector &src) const
{
dst = 0;
template <int dim, int spacedim>
void
MGTransferSelect<number>::build(
- const DoFHandler<dim, spacedim> & mg_dof,
+ const DoFHandler<dim, spacedim> &mg_dof,
unsigned int select,
unsigned int mg_select,
- const std::vector<unsigned int> & t_component,
- const std::vector<unsigned int> & mg_t_component,
+ const std::vector<unsigned int> &t_component,
+ const std::vector<unsigned int> &mg_t_component,
const std::vector<std::set<types::global_dof_index>> &bdry_indices)
{
const FiniteElement<dim> &fe = mg_dof.get_fe();
void
fill_copy_indices(
const DoFHandler<dim, spacedim> &dof_handler,
- const MGConstrainedDoFs * mg_constrained_dofs,
+ const MGConstrainedDoFs *mg_constrained_dofs,
std::vector<std::vector<
std::pair<types::global_dof_index, types::global_dof_index>>>
©_indices,
©_indices_global_mine,
std::vector<std::vector<
std::pair<types::global_dof_index, types::global_dof_index>>>
- & copy_indices_level_mine,
+ ©_indices_level_mine,
const bool skip_interface_dofs)
{
// Now we are filling the variables copy_indices*, which are essentially
for (unsigned int level = 0; level < n_levels; ++level)
{
std::vector<bool> dof_touched(owned_dofs.n_elements(), false);
- const IndexSet & owned_level_dofs =
+ const IndexSet &owned_level_dofs =
dof_handler.locally_owned_mg_dofs(level);
// for the most common case where copy_indices are locally owned
// content in copy_indices_global_mine)
void
reinit_level_partitioner(
- const IndexSet & locally_owned,
+ const IndexSet &locally_owned,
std::vector<types::global_dof_index> &ghosted_level_dofs,
const std::shared_ptr<const Utilities::MPI::Partitioner>
- & external_partitioner,
+ &external_partitioner,
const MPI_Comm communicator,
std::shared_ptr<const Utilities::MPI::Partitioner> &target_partitioner,
Table<2, unsigned int> ©_indices_global_mine)
// Transform the ghost indices to local index space for the vector
inline void
copy_indices_to_mpi_local_numbers(
- const Utilities::MPI::Partitioner & part,
+ const Utilities::MPI::Partitioner &part,
const std::vector<types::global_dof_index> &mine,
const std::vector<types::global_dof_index> &remote,
- std::vector<unsigned int> & localized_indices)
+ std::vector<unsigned int> &localized_indices)
{
localized_indices.resize(mine.size() + remote.size(),
numbers::invalid_unsigned_int);
const unsigned int child,
const unsigned int fe_shift_1d,
const unsigned int fe_degree,
- const std::vector<unsigned int> & lexicographic_numbering,
+ const std::vector<unsigned int> &lexicographic_numbering,
const std::vector<types::global_dof_index> &local_dof_indices,
- types::global_dof_index * target_indices)
+ types::global_dof_index *target_indices)
{
const unsigned int n_child_dofs_1d = fe_degree + 1 + fe_shift_1d;
const unsigned int shift =
template <int dim, typename Number>
void
- setup_element_info(ElementInfo<Number> & elem_info,
+ setup_element_info(ElementInfo<Number> &elem_info,
const FiniteElement<1> &fe,
- const DoFHandler<dim> & dof_handler)
+ const DoFHandler<dim> &dof_handler)
{
// currently, we have only FE_Q and FE_DGQ type elements implemented
elem_info.n_components = dof_handler.get_fe().element_multiplicity(0);
template <int dim, typename Number>
void
setup_transfer(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
const MGConstrainedDoFs *mg_constrained_dofs,
const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
- & external_partitioners,
- ElementInfo<Number> & elem_info,
+ &external_partitioners,
+ ElementInfo<Number> &elem_info,
std::vector<std::vector<unsigned int>> &level_dof_indices,
std::vector<std::vector<std::pair<unsigned int, unsigned int>>>
- & parent_child_connect,
+ &parent_child_connect,
std::vector<unsigned int> &n_owned_level_cells,
std::vector<std::vector<std::vector<unsigned short>>> &dirichlet_indices,
- std::vector<std::vector<Number>> & weights_on_refined,
+ std::vector<std::vector<Number>> &weights_on_refined,
std::vector<Table<2, unsigned int>> ©_indices_global_mine,
MGLevelObject<std::shared_ptr<const Utilities::MPI::Partitioner>>
&target_partitioners)
void
resolve_identity_constraints(
- const MGConstrainedDoFs * mg_constrained_dofs,
+ const MGConstrainedDoFs *mg_constrained_dofs,
const unsigned int level,
std::vector<types::global_dof_index> &dof_indices)
{
void
MGTransferMatrixFree<dim, Number>::prolongate(
const unsigned int to_level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
dst = 0;
void
MGTransferMatrixFree<dim, Number>::prolongate_and_add(
const unsigned int to_level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
Assert((to_level >= 1) && (to_level <= level_dof_indices.size()),
void
MGTransferMatrixFree<dim, Number>::restrict_and_add(
const unsigned int from_level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
Assert((from_level >= 1) && (from_level <= level_dof_indices.size()),
void
MGTransferMatrixFree<dim, Number>::do_prolongate_add(
const unsigned int to_level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const unsigned int vec_size = VectorizedArray<Number>::size();
void
MGTransferMatrixFree<dim, Number>::do_restrict_add(
const unsigned int from_level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const unsigned int vec_size = VectorizedArray<Number>::size();
template <typename VectorType>
void
MGTransferPrebuilt<VectorType>::prolongate(const unsigned int to_level,
- VectorType & dst,
- const VectorType & src) const
+ VectorType &dst,
+ const VectorType &src) const
{
Assert((to_level >= 1) && (to_level <= prolongation_matrices.size()),
ExcIndexRange(to_level, 1, prolongation_matrices.size() + 1));
template <typename VectorType>
void
MGTransferPrebuilt<VectorType>::restrict_and_add(const unsigned int from_level,
- VectorType & dst,
- const VectorType & src) const
+ VectorType &dst,
+ const VectorType &src) const
{
Assert((from_level >= 1) && (from_level <= prolongation_matrices.size()),
ExcIndexRange(from_level, 1, prolongation_matrices.size() + 1));
* and replace with the indices of the dofs to which they are constrained
*/
void
- replace(const MGConstrainedDoFs * mg_constrained_dofs,
+ replace(const MGConstrainedDoFs *mg_constrained_dofs,
const unsigned int level,
std::vector<types::global_dof_index> &dof_indices)
{
template <typename number>
void
-MGTransferBlock<number>::initialize(const std::vector<number> & f,
+MGTransferBlock<number>::initialize(const std::vector<number> &f,
VectorMemory<Vector<number>> &mem)
{
factors = f;
template <typename number>
void
MGTransferBlock<number>::prolongate(const unsigned int to_level,
- BlockVector<number> & dst,
+ BlockVector<number> &dst,
const BlockVector<number> &src) const
{
Assert((to_level >= 1) && (to_level <= prolongation_matrices.size()),
template <typename number>
void
MGTransferBlock<number>::restrict_and_add(const unsigned int from_level,
- BlockVector<number> & dst,
+ BlockVector<number> &dst,
const BlockVector<number> &src) const
{
Assert((from_level >= 1) && (from_level <= prolongation_matrices.size()),
template <typename number>
void
MGTransferSelect<number>::prolongate(const unsigned int to_level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const
{
Assert((to_level >= 1) && (to_level <= prolongation_matrices.size()),
template <typename number>
void
MGTransferSelect<number>::restrict_and_add(const unsigned int from_level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const
{
Assert((from_level >= 1) && (from_level <= prolongation_matrices.size()),
template <typename number>
void
MGTransferBlockSelect<number>::prolongate(const unsigned int to_level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const
{
Assert((to_level >= 1) && (to_level <= prolongation_matrices.size()),
template <typename number>
void
MGTransferBlockSelect<number>::restrict_and_add(const unsigned int from_level,
- Vector<number> & dst,
+ Vector<number> &dst,
const Vector<number> &src) const
{
Assert((from_level >= 1) && (from_level <= prolongation_matrices.size()),
std::pair<std::vector<Point<spacedim>>, std::vector<unsigned int>>
qpoints_over_locally_owned_cells(
const GridTools::Cache<dim0, spacedim> &cache,
- const DoFHandler<dim1, spacedim> & immersed_dh,
- const Quadrature<dim1> & quad,
- const Mapping<dim1, spacedim> & immersed_mapping,
+ const DoFHandler<dim1, spacedim> &immersed_dh,
+ const Quadrature<dim1> &quad,
+ const Mapping<dim1, spacedim> &immersed_mapping,
const bool tria_is_parallel)
{
- const auto & immersed_fe = immersed_dh.get_fe();
+ const auto &immersed_fe = immersed_dh.get_fe();
std::vector<Point<spacedim>> points_over_local_cells;
// Keep track of which cells we actually used
std::vector<unsigned int> used_cells_ids;
*/
template <int dim0, int dim1, int spacedim>
std::pair<std::vector<unsigned int>, std::vector<unsigned int>>
- compute_components_coupling(const ComponentMask & comps0,
- const ComponentMask & comps1,
+ compute_components_coupling(const ComponentMask &comps0,
+ const ComponentMask &comps1,
const FiniteElement<dim0, spacedim> &fe0,
const FiniteElement<dim1, spacedim> &fe1)
{
create_coupling_sparsity_pattern(
const DoFHandler<dim0, spacedim> &space_dh,
const DoFHandler<dim1, spacedim> &immersed_dh,
- const Quadrature<dim1> & quad,
- SparsityPatternBase & sparsity,
- const AffineConstraints<number> & constraints,
- const ComponentMask & space_comps,
- const ComponentMask & immersed_comps,
- const Mapping<dim0, spacedim> & space_mapping,
- const Mapping<dim1, spacedim> & immersed_mapping,
- const AffineConstraints<number> & immersed_constraints)
+ const Quadrature<dim1> &quad,
+ SparsityPatternBase &sparsity,
+ const AffineConstraints<number> &constraints,
+ const ComponentMask &space_comps,
+ const ComponentMask &immersed_comps,
+ const Mapping<dim0, spacedim> &space_mapping,
+ const Mapping<dim1, spacedim> &immersed_mapping,
+ const AffineConstraints<number> &immersed_constraints)
{
GridTools::Cache<dim0, spacedim> cache(space_dh.get_triangulation(),
space_mapping);
void
create_coupling_sparsity_pattern(
const GridTools::Cache<dim0, spacedim> &cache,
- const DoFHandler<dim0, spacedim> & space_dh,
- const DoFHandler<dim1, spacedim> & immersed_dh,
- const Quadrature<dim1> & quad,
- SparsityPatternBase & sparsity,
- const AffineConstraints<number> & constraints,
- const ComponentMask & space_comps,
- const ComponentMask & immersed_comps,
- const Mapping<dim1, spacedim> & immersed_mapping,
- const AffineConstraints<number> & immersed_constraints)
+ const DoFHandler<dim0, spacedim> &space_dh,
+ const DoFHandler<dim1, spacedim> &immersed_dh,
+ const Quadrature<dim1> &quad,
+ SparsityPatternBase &sparsity,
+ const AffineConstraints<number> &constraints,
+ const ComponentMask &space_comps,
+ const ComponentMask &immersed_comps,
+ const Mapping<dim1, spacedim> &immersed_mapping,
+ const AffineConstraints<number> &immersed_constraints)
{
AssertDimension(sparsity.n_rows(), space_dh.n_dofs());
AssertDimension(sparsity.n_cols(), immersed_dh.n_dofs());
template <int dim0, int dim1, int spacedim, typename Matrix>
void
create_coupling_mass_matrix(
- const DoFHandler<dim0, spacedim> & space_dh,
- const DoFHandler<dim1, spacedim> & immersed_dh,
- const Quadrature<dim1> & quad,
- Matrix & matrix,
+ const DoFHandler<dim0, spacedim> &space_dh,
+ const DoFHandler<dim1, spacedim> &immersed_dh,
+ const Quadrature<dim1> &quad,
+ Matrix &matrix,
const AffineConstraints<typename Matrix::value_type> &constraints,
- const ComponentMask & space_comps,
- const ComponentMask & immersed_comps,
- const Mapping<dim0, spacedim> & space_mapping,
- const Mapping<dim1, spacedim> & immersed_mapping,
+ const ComponentMask &space_comps,
+ const ComponentMask &immersed_comps,
+ const Mapping<dim0, spacedim> &space_mapping,
+ const Mapping<dim1, spacedim> &immersed_mapping,
const AffineConstraints<typename Matrix::value_type> &immersed_constraints)
{
GridTools::Cache<dim0, spacedim> cache(space_dh.get_triangulation(),
template <int dim0, int dim1, int spacedim, typename Matrix>
void
create_coupling_mass_matrix(
- const GridTools::Cache<dim0, spacedim> & cache,
- const DoFHandler<dim0, spacedim> & space_dh,
- const DoFHandler<dim1, spacedim> & immersed_dh,
- const Quadrature<dim1> & quad,
- Matrix & matrix,
+ const GridTools::Cache<dim0, spacedim> &cache,
+ const DoFHandler<dim0, spacedim> &space_dh,
+ const DoFHandler<dim1, spacedim> &immersed_dh,
+ const Quadrature<dim1> &quad,
+ Matrix &matrix,
const AffineConstraints<typename Matrix::value_type> &constraints,
- const ComponentMask & space_comps,
- const ComponentMask & immersed_comps,
- const Mapping<dim1, spacedim> & immersed_mapping,
+ const ComponentMask &space_comps,
+ const ComponentMask &immersed_comps,
+ const Mapping<dim1, spacedim> &immersed_mapping,
const AffineConstraints<typename Matrix::value_type> &immersed_constraints)
{
AssertDimension(matrix.m(), space_dh.n_dofs());
// Make sure we act only on locally_owned cells
if (ocell->is_locally_owned())
{
- const std::vector<Point<dim0>> & qps = qpoints[c];
+ const std::vector<Point<dim0>> &qps = qpoints[c];
const std::vector<unsigned int> &ids = maps[c];
FEValues<dim0, spacedim> o_fe_v(cache.get_mapping(),
template <int dim0, int dim1, int spacedim, typename Number>
void
create_coupling_sparsity_pattern(
- const double & epsilon,
+ const double &epsilon,
const GridTools::Cache<dim0, spacedim> &cache0,
const GridTools::Cache<dim1, spacedim> &cache1,
- const DoFHandler<dim0, spacedim> & dh0,
- const DoFHandler<dim1, spacedim> & dh1,
- const Quadrature<dim1> & quad,
- SparsityPatternBase & sparsity,
- const AffineConstraints<Number> & constraints0,
- const ComponentMask & comps0,
- const ComponentMask & comps1)
+ const DoFHandler<dim0, spacedim> &dh0,
+ const DoFHandler<dim1, spacedim> &dh1,
+ const Quadrature<dim1> &quad,
+ SparsityPatternBase &sparsity,
+ const AffineConstraints<Number> &constraints0,
+ const ComponentMask &comps0,
+ const ComponentMask &comps1)
{
if (epsilon == 0.0)
{
template <int dim0, int dim1, int spacedim, typename Matrix>
void
create_coupling_mass_matrix(
- Functions::CutOffFunctionBase<spacedim> & kernel,
- const double & epsilon,
- const GridTools::Cache<dim0, spacedim> & cache0,
- const GridTools::Cache<dim1, spacedim> & cache1,
- const DoFHandler<dim0, spacedim> & dh0,
- const DoFHandler<dim1, spacedim> & dh1,
- const Quadrature<dim0> & quadrature0,
- const Quadrature<dim1> & quadrature1,
- Matrix & matrix,
+ Functions::CutOffFunctionBase<spacedim> &kernel,
+ const double &epsilon,
+ const GridTools::Cache<dim0, spacedim> &cache0,
+ const GridTools::Cache<dim1, spacedim> &cache1,
+ const DoFHandler<dim0, spacedim> &dh0,
+ const DoFHandler<dim1, spacedim> &dh1,
+ const Quadrature<dim0> &quadrature0,
+ const Quadrature<dim1> &quadrature1,
+ Matrix &matrix,
const AffineConstraints<typename Matrix::value_type> &constraints0,
- const ComponentMask & comps0,
- const ComponentMask & comps1)
+ const ComponentMask &comps0,
+ const ComponentMask &comps1)
{
if (epsilon == 0)
{
template void create_coupling_sparsity_pattern(
const DoFHandler<dim0, spacedim> &space_dh,
const DoFHandler<dim1, spacedim> &immersed_dh,
- const Quadrature<dim1> & quad,
- SparsityPatternBase & sparsity,
- const AffineConstraints<S> & constraints,
- const ComponentMask & space_comps,
- const ComponentMask & immersed_comps,
- const Mapping<dim0, spacedim> & space_mapping,
- const Mapping<dim1, spacedim> & immersed_mapping,
- const AffineConstraints<S> & immersed_constraints);
+ const Quadrature<dim1> &quad,
+ SparsityPatternBase &sparsity,
+ const AffineConstraints<S> &constraints,
+ const ComponentMask &space_comps,
+ const ComponentMask &immersed_comps,
+ const Mapping<dim0, spacedim> &space_mapping,
+ const Mapping<dim1, spacedim> &immersed_mapping,
+ const AffineConstraints<S> &immersed_constraints);
template void create_coupling_sparsity_pattern(
const GridTools::Cache<dim0, spacedim> &cache,
- const DoFHandler<dim0, spacedim> & space_dh,
- const DoFHandler<dim1, spacedim> & immersed_dh,
- const Quadrature<dim1> & quad,
- SparsityPatternBase & sparsity,
- const AffineConstraints<S> & constraints,
- const ComponentMask & space_comps,
- const ComponentMask & immersed_comps,
- const Mapping<dim1, spacedim> & immersed_mapping,
- const AffineConstraints<S> & immersed_constraints);
+ const DoFHandler<dim0, spacedim> &space_dh,
+ const DoFHandler<dim1, spacedim> &immersed_dh,
+ const Quadrature<dim1> &quad,
+ SparsityPatternBase &sparsity,
+ const AffineConstraints<S> &constraints,
+ const ComponentMask &space_comps,
+ const ComponentMask &immersed_comps,
+ const Mapping<dim1, spacedim> &immersed_mapping,
+ const AffineConstraints<S> &immersed_constraints);
template void create_coupling_sparsity_pattern(
- const double & epsilon,
+ const double &epsilon,
const GridTools::Cache<dim0, spacedim> &cache0,
const GridTools::Cache<dim1, spacedim> &cache1,
- const DoFHandler<dim0, spacedim> & dh0,
- const DoFHandler<dim1, spacedim> & dh1,
- const Quadrature<dim1> & quad,
- SparsityPatternBase & sparsity,
- const AffineConstraints<S> & constraints0,
- const ComponentMask & comps0,
- const ComponentMask & comps1);
+ const DoFHandler<dim0, spacedim> &dh0,
+ const DoFHandler<dim1, spacedim> &dh1,
+ const Quadrature<dim1> &quad,
+ SparsityPatternBase &sparsity,
+ const AffineConstraints<S> &constraints0,
+ const ComponentMask &comps0,
+ const ComponentMask &comps1);
#endif
}
{
#if dim1 <= spacedim && dim0 <= spacedim
template void create_coupling_mass_matrix(
- const DoFHandler<dim0, spacedim> & space_dh,
- const DoFHandler<dim1, spacedim> & immersed_dh,
- const Quadrature<dim1> & quad,
- Matrix & matrix,
+ const DoFHandler<dim0, spacedim> &space_dh,
+ const DoFHandler<dim1, spacedim> &immersed_dh,
+ const Quadrature<dim1> &quad,
+ Matrix &matrix,
const AffineConstraints<Matrix::value_type> &constraints,
- const ComponentMask & space_comps,
- const ComponentMask & immersed_comps,
- const Mapping<dim0, spacedim> & space_mapping,
- const Mapping<dim1, spacedim> & immersed_mapping,
+ const ComponentMask &space_comps,
+ const ComponentMask &immersed_comps,
+ const Mapping<dim0, spacedim> &space_mapping,
+ const Mapping<dim1, spacedim> &immersed_mapping,
const AffineConstraints<Matrix::value_type> &immersed_constraints);
template void create_coupling_mass_matrix(
- const GridTools::Cache<dim0, spacedim> & cache,
- const DoFHandler<dim0, spacedim> & space_dh,
- const DoFHandler<dim1, spacedim> & immersed_dh,
- const Quadrature<dim1> & quad,
- Matrix & matrix,
+ const GridTools::Cache<dim0, spacedim> &cache,
+ const DoFHandler<dim0, spacedim> &space_dh,
+ const DoFHandler<dim1, spacedim> &immersed_dh,
+ const Quadrature<dim1> &quad,
+ Matrix &matrix,
const AffineConstraints<Matrix::value_type> &constraints,
- const ComponentMask & space_comps,
- const ComponentMask & immersed_comps,
- const Mapping<dim1, spacedim> & immersed_mapping,
+ const ComponentMask &space_comps,
+ const ComponentMask &immersed_comps,
+ const Mapping<dim1, spacedim> &immersed_mapping,
const AffineConstraints<Matrix::value_type> &immersed_constraints);
template void create_coupling_mass_matrix(
Functions::CutOffFunctionBase<spacedim> & kernel,
- const double & epsilon,
- const GridTools::Cache<dim0, spacedim> & cache0,
- const GridTools::Cache<dim1, spacedim> & cache1,
- const DoFHandler<dim0, spacedim> & dh0,
- const DoFHandler<dim1, spacedim> & dh1,
- const Quadrature<dim0> & quadrature0,
- const Quadrature<dim1> & quadrature1,
- Matrix & matrix,
+ const double &epsilon,
+ const GridTools::Cache<dim0, spacedim> &cache0,
+ const GridTools::Cache<dim1, spacedim> &cache1,
+ const DoFHandler<dim0, spacedim> &dh0,
+ const DoFHandler<dim1, spacedim> &dh1,
+ const Quadrature<dim0> &quadrature0,
+ const Quadrature<dim1> &quadrature1,
+ Matrix &matrix,
const AffineConstraints<typename Matrix::value_type> &constraints0,
- const ComponentMask & comps0,
- const ComponentMask & comps1);
+ const ComponentMask &comps0,
+ const ComponentMask &comps1);
#endif
}
{
template <int dim>
FEImmersedSurfaceValues<dim>::FEImmersedSurfaceValues(
- const Mapping<dim> & mapping,
- const FiniteElement<dim> & element,
+ const Mapping<dim> &mapping,
+ const FiniteElement<dim> &element,
const ImmersedSurfaceQuadrature<dim> &quadrature,
const UpdateFlags update_flags)
: FEValuesBase<dim, dim>(quadrature.size(),
template <int dim>
template <typename VectorType>
FEValues<dim>::FEValues(const hp::FECollection<dim> &fe_collection,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const RegionUpdateFlags region_update_flags,
- const MeshClassifier<dim> & mesh_classifier,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
- const AdditionalData & additional_data)
+ const MeshClassifier<dim> &mesh_classifier,
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
+ const AdditionalData &additional_data)
: mapping_collection(&dealii::hp::StaticMappingQ1<dim>::mapping_collection)
, fe_collection(&fe_collection)
, q_collection_1D(quadrature)
template <int dim>
template <typename VectorType>
FEValues<dim>::FEValues(const hp::MappingCollection<dim> &mapping_collection,
- const hp::FECollection<dim> & fe_collection,
- const hp::QCollection<dim> & q_collection,
- const hp::QCollection<1> & q_collection_1D,
+ const hp::FECollection<dim> &fe_collection,
+ const hp::QCollection<dim> &q_collection,
+ const hp::QCollection<1> &q_collection_1D,
const RegionUpdateFlags region_update_flags,
- const MeshClassifier<dim> & mesh_classifier,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
- const AdditionalData & additional_data)
+ const MeshClassifier<dim> &mesh_classifier,
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
+ const AdditionalData &additional_data)
: mapping_collection(&mapping_collection)
, fe_collection(&fe_collection)
, q_collection_1D(q_collection_1D)
template <typename VectorType>
FEInterfaceValues<dim>::FEInterfaceValues(
const hp::FECollection<dim> &fe_collection,
- const Quadrature<1> & quadrature,
+ const Quadrature<1> &quadrature,
const RegionUpdateFlags region_update_flags,
- const MeshClassifier<dim> & mesh_classifier,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
- const AdditionalData & additional_data)
+ const MeshClassifier<dim> &mesh_classifier,
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
+ const AdditionalData &additional_data)
: mapping_collection(&dealii::hp::StaticMappingQ1<dim>::mapping_collection)
, fe_collection(&fe_collection)
, q_collection_1D(quadrature)
template <typename VectorType>
FEInterfaceValues<dim>::FEInterfaceValues(
const hp::MappingCollection<dim> &mapping_collection,
- const hp::FECollection<dim> & fe_collection,
- const hp::QCollection<dim - 1> & q_collection,
- const hp::QCollection<1> & q_collection_1D,
+ const hp::FECollection<dim> &fe_collection,
+ const hp::QCollection<dim - 1> &q_collection,
+ const hp::QCollection<1> &q_collection_1D,
const RegionUpdateFlags region_update_flags,
- const MeshClassifier<dim> & mesh_classifier,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
- const AdditionalData & additional_data)
+ const MeshClassifier<dim> &mesh_classifier,
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
+ const AdditionalData &additional_data)
: mapping_collection(&mapping_collection)
, fe_collection(&fe_collection)
, q_collection_1D(q_collection_1D)
{
template <int dim, int spacedim>
ImmersedSurfaceQuadrature<dim, spacedim>::ImmersedSurfaceQuadrature(
- const std::vector<Point<dim>> & points,
- const std::vector<double> & weights,
+ const std::vector<Point<dim>> &points,
+ const std::vector<double> &weights,
const std::vector<Tensor<1, spacedim>> &normals)
: Quadrature<dim>(points, weights)
, normals(normals)
template <int dim, int spacedim>
void
ImmersedSurfaceQuadrature<dim, spacedim>::push_back(
- const Point<dim> & point,
+ const Point<dim> &point,
const double weight,
const Tensor<1, spacedim> &normal)
{
* Constructor.
*/
DiscreteLevelSetDescription(const DoFHandler<dim> &dof_handler,
- const VectorType & level_set);
+ const VectorType &level_set);
/**
* Return the FECollection of the DoFHandler passed to the constructor.
template <int dim, typename VectorType>
DiscreteLevelSetDescription<dim, VectorType>::DiscreteLevelSetDescription(
const DoFHandler<dim> &dof_handler,
- const VectorType & level_set)
+ const VectorType &level_set)
: dof_handler(&dof_handler)
, level_set(&level_set)
{}
* Constructor. Takes the Function that describes the geometry and the
* element that this function should be interpolated to.
*/
- AnalyticLevelSetDescription(const Function<dim> & level_set,
+ AnalyticLevelSetDescription(const Function<dim> &level_set,
const FiniteElement<dim> &element);
/**
template <int dim>
AnalyticLevelSetDescription<dim>::AnalyticLevelSetDescription(
- const Function<dim> & level_set,
+ const Function<dim> &level_set,
const FiniteElement<dim> &element)
: level_set(&level_set)
, fe_collection(element)
template <int dim>
template <typename VectorType>
MeshClassifier<dim>::MeshClassifier(const DoFHandler<dim> &dof_handler,
- const VectorType & level_set)
+ const VectorType &level_set)
: triangulation(&dof_handler.get_triangulation())
, level_set_description(
std::make_unique<internal::MeshClassifierImplementation::
template <int dim>
MeshClassifier<dim>::MeshClassifier(const Triangulation<dim> &triangulation,
- const Function<dim> & level_set,
+ const Function<dim> &level_set,
const FiniteElement<dim> &element)
: triangulation(&triangulation)
, level_set_description(
for (unsigned int i = 0; i < fe_collection.size(); i++)
{
const FiniteElement<dim> &element = fe_collection[i];
- const FE_Q_Base<dim> * fe_q =
+ const FE_Q_Base<dim> *fe_q =
dynamic_cast<const FE_Q_Base<dim> *>(&element);
Assert(fe_q != nullptr, ExcNotImplemented());
void
tensor_point_with_1D_quadrature(const Point<dim - 1> &point,
const double weight,
- const Quadrature<1> & quadrature1D,
+ const Quadrature<1> &quadrature1D,
const double start,
const double end,
const unsigned int component_in_dim,
template <int dim>
void
add_tensor_product(const Quadrature<dim - 1> &lower,
- const Quadrature<1> & quadrature1D,
+ const Quadrature<1> &quadrature1D,
const double start,
const double end,
const unsigned int component_in_dim,
Definiteness
pointwise_definiteness(
const std::vector<std::reference_wrapper<const Function<dim>>>
- & functions,
+ &functions,
const Point<dim> &point)
{
Assert(functions.size() > 0,
*/
template <int dim>
void
- take_min_max_at_vertices(const Function<dim> & function,
- const BoundingBox<dim> & box,
+ take_min_max_at_vertices(const Function<dim> &function,
+ const BoundingBox<dim> &box,
std::pair<double, double> &value_bounds)
{
const ReferenceCell &cube = ReferenceCells::get_hypercube<dim>();
void
estimate_function_bounds(
const std::vector<std::reference_wrapper<const Function<dim>>>
- & functions,
- const BoundingBox<dim> & box,
+ &functions,
+ const BoundingBox<dim> &box,
std::vector<FunctionBounds<dim>> &all_function_bounds)
{
all_function_bounds.clear();
*/
template <int dim>
void
- map_quadrature_to_box(const Quadrature<dim> & unit_quadrature,
- const BoundingBox<dim> & box,
+ map_quadrature_to_box(const Quadrature<dim> &unit_quadrature,
+ const BoundingBox<dim> &box,
ExtendableQuadrature<dim> &quadrature)
{
for (unsigned int i = 0; i < unit_quadrature.size(); ++i)
void
restrict_to_top_and_bottom(
const std::vector<std::reference_wrapper<const Function<dim>>>
- & functions,
- const BoundingBox<dim> & box,
+ &functions,
+ const BoundingBox<dim> &box,
const unsigned int direction,
std::vector<Functions::CoordinateRestriction<dim - 1>> &restrictions)
{
void
restrict_to_point(
const std::vector<std::reference_wrapper<const Function<dim>>>
- & functions,
- const Point<dim - 1> & point,
+ &functions,
+ const Point<dim - 1> &point,
const unsigned int open_direction,
std::vector<Functions::PointRestriction<dim - 1>> &restrictions)
{
template <int dim>
void
distribute_points_between_roots(
- const Quadrature<1> & quadrature1D,
- const BoundingBox<1> & interval,
+ const Quadrature<1> &quadrature1D,
+ const BoundingBox<1> &interval,
const std::vector<double> &roots,
- const Point<dim - 1> & point,
+ const Point<dim - 1> &point,
const double weight,
const unsigned int height_function_direction,
const std::vector<std::reference_wrapper<const Function<1>>>
- & level_sets,
+ &level_sets,
const AdditionalQGeneratorData &additional_data,
- QPartitioning<dim> & q_partitioning)
+ QPartitioning<dim> &q_partitioning)
{
// Make this int to avoid a warning signed/unsigned comparison.
const int n_roots = roots.size();
void
RootFinder::find_roots(
const std::vector<std::reference_wrapper<const Function<1>>> &functions,
- const BoundingBox<1> & interval,
- std::vector<double> & roots)
+ const BoundingBox<1> &interval,
+ std::vector<double> &roots)
{
for (const Function<1> &function : functions)
{
void
- RootFinder::find_roots(const Function<1> & function,
+ RootFinder::find_roots(const Function<1> &function,
const BoundingBox<1> &interval,
const unsigned int recursion_depth,
- std::vector<double> & roots)
+ std::vector<double> &roots)
{
// Compute function values at end points.
const double left_value = function.value(interval.vertex(0));
*/
template <int dim>
Point<dim>
- face_projection_closest_zero_contour(const Point<dim - 1> & point,
+ face_projection_closest_zero_contour(const Point<dim - 1> &point,
const unsigned int direction,
const BoundingBox<dim> &box,
- const Function<dim> & level_set)
+ const Function<dim> &level_set)
{
const Point<dim> bottom_point =
dealii::internal::create_higher_dim_point(point,
template <int dim, int spacedim>
UpThroughDimensionCreator<dim, spacedim>::UpThroughDimensionCreator(
- const hp::QCollection<1> & q_collection1D,
+ const hp::QCollection<1> &q_collection1D,
const AdditionalQGeneratorData &additional_data)
: q_collection1D(&q_collection1D)
, additional_data(additional_data)
void
UpThroughDimensionCreator<dim, spacedim>::generate(
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
- const BoundingBox<dim> & box,
+ &level_sets,
+ const BoundingBox<dim> &box,
const Quadrature<dim - 1> &low_dim_quadrature,
const unsigned int height_function_direction,
- QPartitioning<dim> & q_partitioning)
+ QPartitioning<dim> &q_partitioning)
{
const Quadrature<1> &quadrature1D = (*q_collection1D)[q_index];
const Point<dim - 1> &point,
const double weight,
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
- const BoundingBox<dim> & box,
+ &level_sets,
+ const BoundingBox<dim> &box,
const unsigned int height_function_direction,
ImmersedSurfaceQuadrature<dim> &surface_quadrature)
{
template <int dim, int spacedim>
QGeneratorBase<dim, spacedim>::QGeneratorBase(
- const hp::QCollection<1> & q_collection1D,
+ const hp::QCollection<1> &q_collection1D,
const AdditionalQGeneratorData &additional_data)
: additional_data(additional_data)
, q_collection1D(&q_collection1D)
template <int dim, int spacedim>
QGenerator<dim, spacedim>::QGenerator(
- const hp::QCollection<1> & q_collection1D,
+ const hp::QCollection<1> &q_collection1D,
const AdditionalQGeneratorData &additional_data)
: QGeneratorBase<dim, spacedim>(q_collection1D, additional_data)
, low_dim_algorithm(q_collection1D, additional_data)
void
QGenerator<dim, spacedim>::generate(
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
+ &level_sets,
const BoundingBox<dim> &box,
const unsigned int n_box_splits)
{
template <int dim>
unsigned int
compute_split_direction(
- const BoundingBox<dim> & box,
+ const BoundingBox<dim> &box,
const std::optional<HeightDirectionData> &height_direction_data)
{
const std::optional<unsigned int> direction =
void
QGenerator<dim, spacedim>::split_box_and_recurse(
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
- const BoundingBox<dim> & box,
+ &level_sets,
+ const BoundingBox<dim> &box,
const std::optional<HeightDirectionData> &direction_data,
const unsigned int n_box_splits)
{
QGenerator<dim, spacedim>::create_low_dim_quadratures(
const unsigned int height_function_direction,
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
+ &level_sets,
const BoundingBox<dim> &box,
const unsigned int n_box_splits)
{
QGenerator<dim, spacedim>::create_high_dim_quadratures(
const unsigned int height_function_direction,
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
+ &level_sets,
const BoundingBox<dim> &box)
{
const QPartitioning<dim - 1> &low_dim_quadratures =
void
QGenerator<dim, spacedim>::use_midpoint_method(
const std::vector<std::reference_wrapper<const Function<dim>>>
- & level_sets,
+ &level_sets,
const BoundingBox<dim> &box)
{
const Point<dim> center = box.center();
template <int spacedim>
QGenerator<1, spacedim>::QGenerator(
- const hp::QCollection<1> & q_collection1D,
+ const hp::QCollection<1> &q_collection1D,
const AdditionalQGeneratorData &additional_data)
: QGeneratorBase<1, spacedim>(q_collection1D, additional_data)
, root_finder(
void
QGenerator<1, spacedim>::generate(
const std::vector<std::reference_wrapper<const Function<1>>>
- & level_sets,
+ &level_sets,
const BoundingBox<1> &box,
const unsigned int n_box_splits)
{
* object.
*/
RefSpaceFEFieldFunction(const DoFHandler<dim> &dof_handler,
- const VectorType & dof_values);
+ const VectorType &dof_values);
/**
* @copydoc CellWiseFunction::set_active_cell()
*/
void
set_subcell(const std::vector<unsigned int> &mask,
- const BoundingBox<dim> & subcell_box) override;
+ const BoundingBox<dim> &subcell_box) override;
/**
* @copydoc CellWiseFunction::is_fe_q_iso_q1()
* checked.
*/
double
- value(const Point<dim> & point,
+ value(const Point<dim> &point,
const unsigned int component = 0) const override;
/**
* checked.
*/
Tensor<1, dim>
- gradient(const Point<dim> & point,
+ gradient(const Point<dim> &point,
const unsigned int component = 0) const override;
/**
* checked.
*/
SymmetricTensor<2, dim>
- hessian(const Point<dim> & point,
+ hessian(const Point<dim> &point,
const unsigned int component = 0) const override;
private:
template <int dim, typename VectorType>
RefSpaceFEFieldFunction<dim, VectorType>::RefSpaceFEFieldFunction(
const DoFHandler<dim> &dof_handler,
- const VectorType & dof_values)
+ const VectorType &dof_values)
: dof_handler(&dof_handler)
, global_dof_values(&dof_values)
, n_subdivisions_per_line(numbers::invalid_unsigned_int)
void
RefSpaceFEFieldFunction<dim, VectorType>::set_subcell(
const std::vector<unsigned int> &mask,
- const BoundingBox<dim> & subcell_box)
+ const BoundingBox<dim> &subcell_box)
{
for (unsigned int i = 0; i < local_dof_values_subcell.size(); ++i)
local_dof_values_subcell[i] = local_dof_values[renumber[mask[i]]];
template <int dim, typename VectorType>
double
RefSpaceFEFieldFunction<dim, VectorType>::value(
- const Point<dim> & point,
+ const Point<dim> &point,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim, typename VectorType>
Tensor<1, dim>
RefSpaceFEFieldFunction<dim, VectorType>::gradient(
- const Point<dim> & point,
+ const Point<dim> &point,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim, typename VectorType>
SymmetricTensor<2, dim>
RefSpaceFEFieldFunction<dim, VectorType>::hessian(
- const Point<dim> & point,
+ const Point<dim> &point,
const unsigned int component) const
{
AssertIndexRange(component, this->n_components);
template <int dim>
BoundingBox<dim>
- create_subcell_box(const BoundingBox<dim> & unit_box,
+ create_subcell_box(const BoundingBox<dim> &unit_box,
const std::array<unsigned int, dim> &subcell_indices,
const unsigned int n_subdivisions)
{
template <int dim>
QuadratureGenerator<dim>::QuadratureGenerator(
const hp::QCollection<1> &q_collection,
- const AdditionalData & additional_data)
+ const AdditionalData &additional_data)
: q_generator(q_collection, additional_data)
{
Assert(q_collection.size() > 0,
template <int dim>
void
- QuadratureGenerator<dim>::generate(const Function<dim> & level_set,
+ QuadratureGenerator<dim>::generate(const Function<dim> &level_set,
const BoundingBox<dim> &box)
{
clear_quadratures();
template <int dim>
void
- QuadratureGenerator<dim>::generate_append(const Function<dim> & level_set,
+ QuadratureGenerator<dim>::generate_append(const Function<dim> &level_set,
const BoundingBox<dim> &box)
{
Assert(level_set.n_components == 1,
template <int dim>
FaceQuadratureGenerator<dim>::FaceQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
- const AdditionalData & additional_data)
+ const AdditionalData &additional_data)
: quadrature_generator(quadratures1D, additional_data)
{}
template <int dim>
void
- FaceQuadratureGenerator<dim>::generate(const Function<dim> & level_set,
+ FaceQuadratureGenerator<dim>::generate(const Function<dim> &level_set,
const BoundingBox<dim> &box,
const unsigned int face_index)
{
FaceQuadratureGenerator<1>::FaceQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
- const AdditionalData & additional_data)
+ const AdditionalData &additional_data)
{
(void)quadratures1D;
(void)additional_data;
void
- FaceQuadratureGenerator<1>::generate(const Function<1> & level_set,
+ FaceQuadratureGenerator<1>::generate(const Function<1> &level_set,
const BoundingBox<1> &box,
const unsigned int face_index)
{
void
- FaceQuadratureGenerator<1>::generate_append(const Function<1> & level_set,
+ FaceQuadratureGenerator<1>::generate_append(const Function<1> &level_set,
const BoundingBox<1> &box,
const unsigned int face_index)
{
template <typename VectorType>
DiscreteQuadratureGenerator<dim>::DiscreteQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
- const AdditionalData & additional_data)
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
+ const AdditionalData &additional_data)
: QuadratureGenerator<dim>(quadratures1D, additional_data)
, reference_space_level_set(
std::make_unique<internal::DiscreteQuadratureGeneratorImplementation::
template <typename VectorType>
DiscreteFaceQuadratureGenerator<dim>::DiscreteFaceQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
- const DoFHandler<dim> & dof_handler,
- const VectorType & level_set,
- const AdditionalData & additional_data)
+ const DoFHandler<dim> &dof_handler,
+ const VectorType &level_set,
+ const AdditionalData &additional_data)
: FaceQuadratureGenerator<dim>(quadratures1D, additional_data)
, reference_space_level_set(
std::make_unique<internal::DiscreteQuadratureGeneratorImplementation::
const dealii::hp::MappingCollection<dim, spacedim> &mapping,
const std::vector<
std::shared_ptr<dealii::hp::FECollection<dim, spacedim>>>
- & finite_elements,
+ &finite_elements,
const UpdateFlags update_flags,
const std::vector<std::vector<unsigned int>> &cell_to_patch_index_map)
: ParallelDataBase<dim, spacedim>(n_datasets,
template <int dim, int spacedim>
void
DataOut<dim, spacedim>::build_one_patch(
- const std::pair<cell_iterator, unsigned int> * cell_and_index,
+ const std::pair<cell_iterator, unsigned int> *cell_and_index,
internal::DataOutImplementation::ParallelData<dim, spacedim> &scratch_data,
const unsigned int n_subdivisions,
const CurvedCellRegion curved_cell_region)
void
DataOut<dim, spacedim>::set_cell_selection(
const std::function<cell_iterator(const Triangulation<dim, spacedim> &)>
- & first_cell,
+ &first_cell,
const std::function<cell_iterator(const Triangulation<dim, spacedim> &,
const cell_iterator &)> &next_cell)
{
const unsigned int n_datasets,
const unsigned int n_subdivisions,
const std::vector<unsigned int> &n_postprocessor_outputs,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const std::vector<
std::shared_ptr<dealii::hp::FECollection<dim, spacedim>>>
- & finite_elements,
+ &finite_elements,
const UpdateFlags update_flags)
: internal::DataOutImplementation::ParallelDataBase<dim, spacedim>(
n_datasets,
DataOutFaces<dim, spacedim>::build_one_patch(
const FaceDescriptor *cell_and_face,
internal::DataOutFacesImplementation::ParallelData<dim, spacedim> &data,
- DataOutBase::Patch<patch_dim, patch_spacedim> & patch)
+ DataOutBase::Patch<patch_dim, patch_spacedim> &patch)
{
const cell_iterator cell = cell_and_face->first;
const unsigned int face_number = cell_and_face->second;
// we treat single component functions separately for efficiency
// reasons.
if (n_components == 1)
- {
- this->dof_data[dataset]->get_function_values(
- this_fe_patch_values,
- internal::DataOutImplementation::ComponentExtractor::real_part,
- data.patch_values_scalar.solution_values);
- for (unsigned int q = 0; q < n_q_points; ++q)
- patch.data(offset, q) =
- data.patch_values_scalar.solution_values[q];
- }
- else
- {
- data.resize_system_vectors(n_components);
- this->dof_data[dataset]->get_function_values(
- this_fe_patch_values,
- internal::DataOutImplementation::ComponentExtractor::real_part,
- data.patch_values_system.solution_values);
- for (unsigned int component = 0; component < n_components;
- ++component)
+ {
+ this->dof_data[dataset]->get_function_values(
+ this_fe_patch_values,
+ internal::DataOutImplementation::ComponentExtractor::
+ real_part,
+ data.patch_values_scalar.solution_values);
for (unsigned int q = 0; q < n_q_points; ++q)
- patch.data(offset + component, q) =
- data.patch_values_system.solution_values[q](component);
- }
+ patch.data(offset, q) =
+ data.patch_values_scalar.solution_values[q];
+ }
+ else
+ {
+ data.resize_system_vectors(n_components);
+ this->dof_data[dataset]->get_function_values(
+ this_fe_patch_values,
+ internal::DataOutImplementation::ComponentExtractor::
+ real_part,
+ data.patch_values_system.solution_values);
+ for (unsigned int component = 0; component < n_components;
+ ++component)
+ for (unsigned int q = 0; q < n_q_points; ++q)
+ patch.data(offset + component, q) =
+ data.patch_values_system.solution_values[q](component);
+ }
// increment the counter for the actual data record
offset += this->dof_data[dataset]->n_output_variables;
}
template <int dim, int patch_dim, int spacedim>
DataOutResample<dim, patch_dim, spacedim>::DataOutResample(
const Triangulation<patch_dim, spacedim> &patch_tria,
- const Mapping<patch_dim, spacedim> & patch_mapping)
+ const Mapping<patch_dim, spacedim> &patch_mapping)
: patch_dof_handler(patch_tria)
, patch_mapping(&patch_mapping)
{}
template <int dim, int patch_dim, int spacedim>
void
DataOutResample<dim, patch_dim, spacedim>::build_patches(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const unsigned int n_subdivisions,
const typename DataOut<patch_dim, spacedim>::CurvedCellRegion curved_region)
{
const unsigned int n_subdivisions,
const unsigned int n_patches_per_circle,
const std::vector<unsigned int> &n_postprocessor_outputs,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const std::vector<
std::shared_ptr<dealii::hp::FECollection<dim, spacedim>>>
- & finite_elements,
+ &finite_elements,
const UpdateFlags update_flags)
: internal::DataOutImplementation::ParallelDataBase<dim, spacedim>(
n_datasets,
template <int dim, int spacedim>
void
DataOutRotation<dim, spacedim>::build_one_patch(
- const cell_iterator * cell,
+ const cell_iterator *cell,
internal::DataOutRotationImplementation::ParallelData<dim, spacedim> &data,
std::vector<DataOutBase::Patch<patch_dim, patch_spacedim>> &my_patches)
{
[this](
const cell_iterator *cell,
internal::DataOutRotationImplementation::ParallelData<dim, spacedim>
- & data,
+ &data,
std::vector<DataOutBase::Patch<patch_dim, patch_spacedim>> &my_patches) {
this->build_one_patch(cell, data, my_patches);
},
template <typename number>
void
DataOutStack<dim, spacedim>::add_data_vector(const Vector<number> &vec,
- const std::string & name)
+ const std::string &name)
{
const unsigned int n_components = dof_handler->get_fe(0).n_components();
template <typename number>
void
DataOutStack<dim, spacedim>::add_data_vector(
- const Vector<number> & vec,
+ const Vector<number> &vec,
const std::vector<std::string> &names)
{
Assert(dof_handler != nullptr,
void
BoundaryIds<dim>::evaluate_scalar_field(
const DataPostprocessorInputs::Scalar<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
AssertDimension(computed_quantities.size(), inputs.solution_values.size());
template <class InputVector, int spacedim>
static ProjectedDerivative
get_projected_derivative(const FEValues<dim, spacedim> &fe_values,
- const InputVector & solution,
+ const InputVector &solution,
const unsigned int component);
/**
inline typename Gradient<dim>::ProjectedDerivative
Gradient<dim>::get_projected_derivative(
const FEValues<dim, spacedim> &fe_values,
- const InputVector & solution,
+ const InputVector &solution,
const unsigned int component)
{
if (fe_values.get_fe().n_components() == 1)
template <class InputVector, int spacedim>
static ProjectedDerivative
get_projected_derivative(const FEValues<dim, spacedim> &fe_values,
- const InputVector & solution,
+ const InputVector &solution,
const unsigned int component);
/**
inline typename SecondDerivative<dim>::ProjectedDerivative
SecondDerivative<dim>::get_projected_derivative(
const FEValues<dim, spacedim> &fe_values,
- const InputVector & solution,
+ const InputVector &solution,
const unsigned int component)
{
if (fe_values.get_fe().n_components() == 1)
template <class InputVector, int spacedim>
static ProjectedDerivative
get_projected_derivative(const FEValues<dim, spacedim> &fe_values,
- const InputVector & solution,
+ const InputVector &solution,
const unsigned int component);
/**
inline typename ThirdDerivative<dim>::ProjectedDerivative
ThirdDerivative<dim>::get_projected_derivative(
const FEValues<dim, spacedim> &fe_values,
- const InputVector & solution,
+ const InputVector &solution,
const unsigned int component)
{
if (fe_values.get_fe().n_components() == 1)
int spacedim>
void
approximate_cell(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const InputVector & solution,
+ const InputVector &solution,
const unsigned int component,
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
typename DerivativeDescription::Derivative &derivative)
const SynchronousIterators<
std::tuple<typename DoFHandler<dim, spacedim>::active_cell_iterator,
Vector<float>::iterator>> &cell,
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
- const InputVector & solution,
+ const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const InputVector &solution,
const unsigned int component)
{
// if the cell is not locally owned, then there is nothing to do
class InputVector,
int spacedim>
void
- approximate_derivative(const Mapping<dim, spacedim> & mapping,
+ approximate_derivative(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const InputVector & solution,
+ const InputVector &solution,
const unsigned int component,
- Vector<float> & derivative_norm)
+ Vector<float> &derivative_norm)
{
Assert(derivative_norm.size() ==
dof_handler.get_triangulation().n_active_cells(),
{
template <int dim, class InputVector, int spacedim>
void
- approximate_gradient(const Mapping<dim, spacedim> & mapping,
+ approximate_gradient(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const InputVector & solution,
- Vector<float> & derivative_norm,
+ const InputVector &solution,
+ Vector<float> &derivative_norm,
const unsigned int component)
{
internal::approximate_derivative<internal::Gradient<dim>, dim>(
template <int dim, class InputVector, int spacedim>
void
approximate_gradient(const DoFHandler<dim, spacedim> &dof_handler,
- const InputVector & solution,
- Vector<float> & derivative_norm,
+ const InputVector &solution,
+ Vector<float> &derivative_norm,
const unsigned int component)
{
Assert(!dof_handler.get_triangulation().is_mixed_mesh(),
template <int dim, class InputVector, int spacedim>
void
- approximate_second_derivative(const Mapping<dim, spacedim> & mapping,
+ approximate_second_derivative(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler,
- const InputVector & solution,
- Vector<float> & derivative_norm,
+ const InputVector &solution,
+ Vector<float> &derivative_norm,
const unsigned int component)
{
internal::approximate_derivative<internal::SecondDerivative<dim>, dim>(
template <int dim, class InputVector, int spacedim>
void
approximate_second_derivative(const DoFHandler<dim, spacedim> &dof_handler,
- const InputVector & solution,
- Vector<float> & derivative_norm,
+ const InputVector &solution,
+ Vector<float> &derivative_norm,
const unsigned int component)
{
Assert(!dof_handler.get_triangulation().is_mixed_mesh(),
template <int dim, int spacedim, class InputVector, int order>
void
approximate_derivative_tensor(
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof,
- const InputVector & solution,
+ const InputVector &solution,
#ifndef _MSC_VER
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
#else
void
approximate_derivative_tensor(
const DoFHandler<dim, spacedim> &dof,
- const InputVector & solution,
+ const InputVector &solution,
#ifndef _MSC_VER
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
#else
\{
template void
approximate_gradient<deal_II_dimension>(
- const Mapping<deal_II_dimension> & mapping,
+ const Mapping<deal_II_dimension> &mapping,
const DoFHandler<deal_II_dimension> &dof_handler,
- const VEC & solution,
- Vector<float> & derivative_norm,
+ const VEC &solution,
+ Vector<float> &derivative_norm,
const unsigned int component);
template void
approximate_gradient<deal_II_dimension>(
const DoFHandler<deal_II_dimension> &dof_handler,
- const VEC & solution,
- Vector<float> & derivative_norm,
+ const VEC &solution,
+ Vector<float> &derivative_norm,
const unsigned int component);
template void
approximate_second_derivative<deal_II_dimension>(
- const Mapping<deal_II_dimension> & mapping,
+ const Mapping<deal_II_dimension> &mapping,
const DoFHandler<deal_II_dimension> &dof_handler,
- const VEC & solution,
- Vector<float> & derivative_norm,
+ const VEC &solution,
+ Vector<float> &derivative_norm,
const unsigned int component);
template void
approximate_second_derivative<deal_II_dimension>(
const DoFHandler<deal_II_dimension> &dof_handler,
- const VEC & solution,
- Vector<float> & derivative_norm,
+ const VEC &solution,
+ Vector<float> &derivative_norm,
const unsigned int component);
template void
deal_II_dimension,
VEC,
1>(
- const Mapping<deal_II_dimension> & mapping,
- const DoFHandler<deal_II_dimension> & dof_handler,
- const VEC & solution,
+ const Mapping<deal_II_dimension> &mapping,
+ const DoFHandler<deal_II_dimension> &dof_handler,
+ const VEC &solution,
const DoFHandler<deal_II_dimension>::active_cell_iterator &cell,
- Tensor<1, deal_II_dimension> & derivative,
+ Tensor<1, deal_II_dimension> &derivative,
const unsigned int component);
template void
deal_II_dimension,
VEC,
2>(
- const Mapping<deal_II_dimension> & mapping,
- const DoFHandler<deal_II_dimension> & dof_handler,
- const VEC & solution,
+ const Mapping<deal_II_dimension> &mapping,
+ const DoFHandler<deal_II_dimension> &dof_handler,
+ const VEC &solution,
const DoFHandler<deal_II_dimension>::active_cell_iterator &cell,
- Tensor<2, deal_II_dimension> & derivative,
+ Tensor<2, deal_II_dimension> &derivative,
const unsigned int component);
template void
deal_II_dimension,
VEC,
3>(
- const Mapping<deal_II_dimension> & mapping,
- const DoFHandler<deal_II_dimension> & dof_handler,
- const VEC & solution,
+ const Mapping<deal_II_dimension> &mapping,
+ const DoFHandler<deal_II_dimension> &dof_handler,
+ const VEC &solution,
const DoFHandler<deal_II_dimension>::active_cell_iterator &cell,
- Tensor<3, deal_II_dimension> & derivative,
+ Tensor<3, deal_II_dimension> &derivative,
const unsigned int component);
deal_II_dimension,
VEC,
1>(
- const DoFHandler<deal_II_dimension> & dof_handler,
- const VEC & solution,
+ const DoFHandler<deal_II_dimension> &dof_handler,
+ const VEC &solution,
const DoFHandler<deal_II_dimension>::active_cell_iterator &cell,
- Tensor<1, deal_II_dimension> & derivative,
+ Tensor<1, deal_II_dimension> &derivative,
const unsigned int component);
template void
deal_II_dimension,
VEC,
2>(
- const DoFHandler<deal_II_dimension> & dof_handler,
- const VEC & solution,
+ const DoFHandler<deal_II_dimension> &dof_handler,
+ const VEC &solution,
const DoFHandler<deal_II_dimension>::active_cell_iterator &cell,
- Tensor<2, deal_II_dimension> & derivative,
+ Tensor<2, deal_II_dimension> &derivative,
const unsigned int component);
template void
deal_II_dimension,
VEC,
3>(
- const DoFHandler<deal_II_dimension> & dof_handler,
- const VEC & solution,
+ const DoFHandler<deal_II_dimension> &dof_handler,
+ const VEC &solution,
const DoFHandler<deal_II_dimension>::active_cell_iterator &cell,
- Tensor<3, deal_II_dimension> & derivative,
+ Tensor<3, deal_II_dimension> &derivative,
const unsigned int component);
\}
template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
- const Mapping<1, spacedim> & mapping,
+ const Mapping<1, spacedim> &mapping,
const DoFHandler<1, spacedim> &dof_handler,
- const Quadrature<0> & quadrature,
+ const Quadrature<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask,
+ Vector<float> &error,
+ const ComponentMask &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
void
KellyErrorEstimator<1, spacedim>::estimate(
const DoFHandler<1, spacedim> &dof_handler,
- const Quadrature<0> & quadrature,
+ const Quadrature<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask,
+ Vector<float> &error,
+ const ComponentMask &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
void
KellyErrorEstimator<1, spacedim>::estimate(
const DoFHandler<1, spacedim> &dof_handler,
- const Quadrature<0> & quadrature,
+ const Quadrature<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask,
+ const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
const types::material_id material_id,
template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
- const Mapping<1, spacedim> & mapping,
+ const Mapping<1, spacedim> &mapping,
const DoFHandler<1, spacedim> &dof_handler,
- const hp::QCollection<0> & quadrature,
+ const hp::QCollection<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask,
+ Vector<float> &error,
+ const ComponentMask &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
void
KellyErrorEstimator<1, spacedim>::estimate(
const DoFHandler<1, spacedim> &dof_handler,
- const hp::QCollection<0> & quadrature,
+ const hp::QCollection<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ReadVector<Number> &solution,
- Vector<float> & error,
- const ComponentMask & component_mask,
+ Vector<float> &error,
+ const ComponentMask &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
void
KellyErrorEstimator<1, spacedim>::estimate(
const DoFHandler<1, spacedim> &dof_handler,
- const hp::QCollection<0> & quadrature,
+ const hp::QCollection<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask,
+ const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
const types::material_id material_id,
template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
- const Mapping<1, spacedim> & mapping,
+ const Mapping<1, spacedim> &mapping,
const DoFHandler<1, spacedim> &dof_handler,
const hp::QCollection<0> &,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficient,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask,
+ const Function<spacedim> *coefficient,
const unsigned int,
const types::subdomain_id subdomain_id_,
const types::material_id material_id,
template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
- const Mapping<1, spacedim> & mapping,
+ const Mapping<1, spacedim> &mapping,
const DoFHandler<1, spacedim> &dof_handler,
- const Quadrature<0> & quadrature,
+ const Quadrature<0> &quadrature,
const std::map<types::boundary_id, const Function<spacedim, Number> *>
- & neumann_bc,
+ &neumann_bc,
const ArrayView<const ReadVector<Number> *> &solutions,
- ArrayView<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
+ ArrayView<Vector<float> *> &errors,
+ const ComponentMask &component_mask,
+ const Function<spacedim> *coefficients,
const unsigned int n_threads,
const types::subdomain_id subdomain_id,
const types::material_id material_id,
template <typename number>
void
Histogram::evaluate(const std::vector<Vector<number>> &values,
- const std::vector<double> & y_values_,
+ const std::vector<double> &y_values_,
const unsigned int n_intervals,
const IntervalSpacing interval_spacing)
{
// explicit instantiations for float
template void
Histogram::evaluate<float>(const std::vector<Vector<float>> &values,
- const std::vector<double> & y_values,
+ const std::vector<double> &y_values,
const unsigned int n_intervals,
const IntervalSpacing interval_spacing);
template void
-Histogram::evaluate<float>(const Vector<float> & values,
+Histogram::evaluate<float>(const Vector<float> &values,
const unsigned int n_intervals,
const IntervalSpacing interval_spacing);
// explicit instantiations for double
template void
Histogram::evaluate<double>(const std::vector<Vector<double>> &values,
- const std::vector<double> & y_values,
+ const std::vector<double> &y_values,
const unsigned int n_intervals,
const IntervalSpacing interval_spacing);
template void
template void MatrixCreator::create_mass_matrix<deal_II_dimension,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> & mapping,
+ const Mapping<deal_II_dimension, deal_II_space_dimension> &mapping,
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
- const Quadrature<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const Quadrature<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_space_dimension,
typename deal_II_sparse_matrix_type::value_type>
*const coefficient,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
- const Quadrature<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const Quadrature<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_space_dimension,
typename deal_II_sparse_matrix_type::value_type>
*const coefficient,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
const hp::MappingCollection<deal_II_dimension, deal_II_space_dimension>
- & mapping,
+ &mapping,
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
- const hp::QCollection<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const hp::QCollection<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_space_dimension,
typename deal_II_sparse_matrix_type::value_type>
*const coefficient,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
- const hp::QCollection<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const hp::QCollection<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_space_dimension,
typename deal_II_sparse_matrix_type::value_type>
*const coefficient,
template void MatrixCreator::create_mass_matrix<deal_II_dimension,
deal_II_space_dimension,
SparseMatrix<scalar>>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> & mapping,
+ const Mapping<deal_II_dimension, deal_II_space_dimension> &mapping,
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
- const Quadrature<deal_II_dimension> & q,
- SparseMatrix<scalar> & matrix,
- const Function<deal_II_space_dimension, scalar> & rhs,
- Vector<scalar> & rhs_vector,
+ const Quadrature<deal_II_dimension> &q,
+ SparseMatrix<scalar> &matrix,
+ const Function<deal_II_space_dimension, scalar> &rhs,
+ Vector<scalar> &rhs_vector,
const Function<deal_II_space_dimension, scalar> *const coefficient,
const AffineConstraints<scalar> &constraints);
template void MatrixCreator::create_mass_matrix<deal_II_dimension,
deal_II_space_dimension,
SparseMatrix<scalar>>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
- const Quadrature<deal_II_dimension> & q,
- SparseMatrix<scalar> & matrix,
- const Function<deal_II_space_dimension, scalar> & rhs,
- Vector<scalar> & rhs_vector,
+ const Quadrature<deal_II_dimension> &q,
+ SparseMatrix<scalar> &matrix,
+ const Function<deal_II_space_dimension, scalar> &rhs,
+ Vector<scalar> &rhs_vector,
const Function<deal_II_space_dimension, scalar> *const coefficient,
const AffineConstraints<scalar> &constraints);
deal_II_space_dimension,
SparseMatrix<scalar>>(
const hp::MappingCollection<deal_II_dimension, deal_II_space_dimension>
- & mapping,
+ &mapping,
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
- const hp::QCollection<deal_II_dimension> & q,
- SparseMatrix<scalar> & matrix,
- const Function<deal_II_space_dimension, scalar> & rhs,
- Vector<scalar> & rhs_vector,
+ const hp::QCollection<deal_II_dimension> &q,
+ SparseMatrix<scalar> &matrix,
+ const Function<deal_II_space_dimension, scalar> &rhs,
+ Vector<scalar> &rhs_vector,
const Function<deal_II_space_dimension, scalar> *const coefficient,
const AffineConstraints<scalar> &constraints);
deal_II_space_dimension,
SparseMatrix<scalar>>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
- const hp::QCollection<deal_II_dimension> & q,
- SparseMatrix<scalar> & matrix,
- const Function<deal_II_space_dimension, scalar> & rhs,
- Vector<scalar> & rhs_vector,
+ const hp::QCollection<deal_II_dimension> &q,
+ SparseMatrix<scalar> &matrix,
+ const Function<deal_II_space_dimension, scalar> &rhs,
+ Vector<scalar> &rhs_vector,
const Function<deal_II_space_dimension, scalar> *const coefficient,
const AffineConstraints<scalar> &constraints);
#endif
MatrixCreator::create_boundary_mass_matrix<deal_II_dimension,
deal_II_space_dimension,
scalar>(
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> & dof,
- const Quadrature<deal_II_dimension - 1> & q,
- SparseMatrix<scalar> & matrix,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
+ const Quadrature<deal_II_dimension - 1> &q,
+ SparseMatrix<scalar> &matrix,
const std::map<types::boundary_id,
const Function<deal_II_space_dimension, scalar> *> &rhs,
- Vector<scalar> & rhs_vector,
+ Vector<scalar> &rhs_vector,
std::vector<types::global_dof_index> &dof_to_boundary_mapping,
const Function<deal_II_space_dimension, scalar> *const a,
std::vector<unsigned int>);
deal_II_space_dimension,
scalar>(
const Mapping<deal_II_dimension, deal_II_space_dimension> &,
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> & dof,
- const Quadrature<deal_II_dimension - 1> & q,
- SparseMatrix<scalar> & matrix,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
+ const Quadrature<deal_II_dimension - 1> &q,
+ SparseMatrix<scalar> &matrix,
const std::map<types::boundary_id,
const Function<deal_II_space_dimension, scalar> *> &rhs,
- Vector<scalar> & rhs_vector,
+ Vector<scalar> &rhs_vector,
std::vector<types::global_dof_index> &dof_to_boundary_mapping,
const Function<deal_II_space_dimension, scalar> *const a,
std::vector<unsigned int>);
deal_II_sparse_matrix_type>(
const DoFHandler<deal_II_dimension> &dof,
const Quadrature<deal_II_dimension> &q,
- deal_II_sparse_matrix_type & matrix,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_dimension,
typename deal_II_sparse_matrix_type::value_type>
*const coefficient,
MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
- const Mapping<deal_II_dimension> & mapping,
+ const Mapping<deal_II_dimension> &mapping,
const DoFHandler<deal_II_dimension> &dof,
const Quadrature<deal_II_dimension> &q,
- deal_II_sparse_matrix_type & matrix,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_dimension,
typename deal_II_sparse_matrix_type::value_type>
*const coefficient,
MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
- const Mapping<deal_II_dimension> & mapping,
- const DoFHandler<deal_II_dimension> & dof,
- const Quadrature<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const Mapping<deal_II_dimension> &mapping,
+ const DoFHandler<deal_II_dimension> &dof,
+ const Quadrature<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_dimension,
typename deal_II_sparse_matrix_type::value_type> &rhs,
Vector<typename deal_II_sparse_matrix_type::value_type> &rhs_vector,
MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
- const DoFHandler<deal_II_dimension> & dof,
- const Quadrature<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const DoFHandler<deal_II_dimension> &dof,
+ const Quadrature<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_dimension,
typename deal_II_sparse_matrix_type::value_type> &rhs,
Vector<typename deal_II_sparse_matrix_type::value_type> &rhs_vector,
MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
- const DoFHandler<deal_II_dimension> & dof,
+ const DoFHandler<deal_II_dimension> &dof,
const hp::QCollection<deal_II_dimension> &q,
- deal_II_sparse_matrix_type & matrix,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_dimension,
typename deal_II_sparse_matrix_type::value_type>
*const coefficient,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
const hp::MappingCollection<deal_II_dimension> &mapping,
- const DoFHandler<deal_II_dimension> & dof,
- const hp::QCollection<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const DoFHandler<deal_II_dimension> &dof,
+ const hp::QCollection<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_dimension,
typename deal_II_sparse_matrix_type::value_type>
*const coefficient,
MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
- const hp::MappingCollection<deal_II_dimension> & mapping,
- const DoFHandler<deal_II_dimension> & dof,
- const hp::QCollection<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const hp::MappingCollection<deal_II_dimension> &mapping,
+ const DoFHandler<deal_II_dimension> &dof,
+ const hp::QCollection<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_dimension,
typename deal_II_sparse_matrix_type::value_type> &rhs,
Vector<typename deal_II_sparse_matrix_type::value_type> &rhs_vector,
MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
- const DoFHandler<deal_II_dimension> & dof,
- const hp::QCollection<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const DoFHandler<deal_II_dimension> &dof,
+ const hp::QCollection<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_dimension,
typename deal_II_sparse_matrix_type::value_type> &rhs,
Vector<typename deal_II_sparse_matrix_type::value_type> &rhs_vector,
MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> & mapping,
+ const Mapping<deal_II_dimension, deal_II_space_dimension> &mapping,
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
- const Quadrature<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const Quadrature<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_space_dimension,
typename deal_II_sparse_matrix_type::value_type>
*const coefficient,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
- const Quadrature<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const Quadrature<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_space_dimension,
typename deal_II_sparse_matrix_type::value_type>
*const coefficient,
MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> & mapping,
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> & dof,
- const Quadrature<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const Mapping<deal_II_dimension, deal_II_space_dimension> &mapping,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
+ const Quadrature<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_space_dimension,
typename deal_II_sparse_matrix_type::value_type> &rhs,
Vector<typename deal_II_sparse_matrix_type::value_type> &rhs_vector,
MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension,
deal_II_sparse_matrix_type>(
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> & dof,
- const Quadrature<deal_II_dimension> & q,
- deal_II_sparse_matrix_type & matrix,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
+ const Quadrature<deal_II_dimension> &q,
+ deal_II_sparse_matrix_type &matrix,
const Function<deal_II_space_dimension,
typename deal_II_sparse_matrix_type::value_type> &rhs,
Vector<typename deal_II_sparse_matrix_type::value_type> &rhs_vector,
void
apply_boundary_values(
const std::map<types::global_dof_index, number> &boundary_values,
- SparseMatrix<number> & matrix,
- Vector<number> & solution,
- Vector<number> & right_hand_side,
+ SparseMatrix<number> &matrix,
+ Vector<number> &solution,
+ Vector<number> &right_hand_side,
const bool eliminate_columns)
{
Assert(matrix.n() == right_hand_side.size(),
void
apply_boundary_values(
const std::map<types::global_dof_index, number> &boundary_values,
- BlockSparseMatrix<number> & matrix,
- BlockVector<number> & solution,
- BlockVector<number> & right_hand_side,
+ BlockSparseMatrix<number> &matrix,
+ BlockVector<number> &solution,
+ BlockVector<number> &right_hand_side,
const bool eliminate_columns)
{
const unsigned int blocks = matrix.n_block_rows();
void
local_apply_boundary_values(
const std::map<types::global_dof_index, number> &boundary_values,
- const std::vector<types::global_dof_index> & local_dof_indices,
- FullMatrix<number> & local_matrix,
- Vector<number> & local_rhs,
+ const std::vector<types::global_dof_index> &local_dof_indices,
+ FullMatrix<number> &local_matrix,
+ Vector<number> &local_rhs,
const bool eliminate_columns)
{
Assert(local_dof_indices.size() == local_matrix.m(),
{
template void MatrixTools::local_apply_boundary_values(
const std::map<types::global_dof_index, number> &boundary_values,
- const std::vector<types::global_dof_index> & local_dof_indices,
- FullMatrix<number> & local_matrix,
- Vector<number> & local_rhs,
+ const std::vector<types::global_dof_index> &local_dof_indices,
+ FullMatrix<number> &local_matrix,
+ Vector<number> &local_rhs,
const bool eliminate_columns);
template void MatrixTools::apply_boundary_values(
const std::map<types::global_dof_index, number> &boundary_values,
- SparseMatrix<number> & matrix,
- Vector<number> & solution,
- Vector<number> & right_hand_side,
+ SparseMatrix<number> &matrix,
+ Vector<number> &solution,
+ Vector<number> &right_hand_side,
const bool eliminate_columns);
template void MatrixTools::apply_boundary_values(
const std::map<types::global_dof_index, number> &boundary_values,
- BlockSparseMatrix<number> & matrix,
- BlockVector<number> & solution,
- BlockVector<number> & right_hand_side,
+ BlockSparseMatrix<number> &matrix,
+ BlockVector<number> &solution,
+ BlockVector<number> &right_hand_side,
const bool eliminate_columns);
}
void
apply_boundary_values(
const std::map<types::global_dof_index, PetscScalar> &boundary_values,
- PETScWrappers::MatrixBase & matrix,
- PETScWrappers::VectorBase & solution,
- PETScWrappers::VectorBase & right_hand_side,
+ PETScWrappers::MatrixBase &matrix,
+ PETScWrappers::VectorBase &solution,
+ PETScWrappers::VectorBase &right_hand_side,
const bool eliminate_columns)
{
Assert(matrix.n() == right_hand_side.size(),
void
apply_boundary_values(
const std::map<types::global_dof_index, PetscScalar> &boundary_values,
- PETScWrappers::MPI::BlockSparseMatrix & matrix,
- PETScWrappers::MPI::BlockVector & solution,
- PETScWrappers::MPI::BlockVector & right_hand_side,
+ PETScWrappers::MPI::BlockSparseMatrix &matrix,
+ PETScWrappers::MPI::BlockVector &solution,
+ PETScWrappers::MPI::BlockVector &right_hand_side,
const bool eliminate_columns)
{
Assert(eliminate_columns == false, ExcNotImplemented());
void
apply_boundary_values(const std::map<types::global_dof_index,
TrilinosScalar> &boundary_values,
- TrilinosMatrix & matrix,
- TrilinosVector & solution,
- TrilinosVector & right_hand_side,
+ TrilinosMatrix &matrix,
+ TrilinosVector &solution,
+ TrilinosVector &right_hand_side,
const bool eliminate_columns)
{
Assert(eliminate_columns == false, ExcNotImplemented());
void
apply_block_boundary_values(
const std::map<types::global_dof_index, TrilinosScalar>
- & boundary_values,
- TrilinosMatrix & matrix,
+ &boundary_values,
+ TrilinosMatrix &matrix,
TrilinosBlockVector &solution,
TrilinosBlockVector &right_hand_side,
const bool eliminate_columns)
void
apply_boundary_values(
const std::map<types::global_dof_index, TrilinosScalar> &boundary_values,
- TrilinosWrappers::SparseMatrix & matrix,
- TrilinosWrappers::MPI::Vector & solution,
- TrilinosWrappers::MPI::Vector & right_hand_side,
+ TrilinosWrappers::SparseMatrix &matrix,
+ TrilinosWrappers::MPI::Vector &solution,
+ TrilinosWrappers::MPI::Vector &right_hand_side,
const bool eliminate_columns)
{
// simply redirect to the generic function
void
apply_boundary_values(
const std::map<types::global_dof_index, TrilinosScalar> &boundary_values,
- TrilinosWrappers::BlockSparseMatrix & matrix,
- TrilinosWrappers::MPI::BlockVector & solution,
- TrilinosWrappers::MPI::BlockVector & right_hand_side,
+ TrilinosWrappers::BlockSparseMatrix &matrix,
+ TrilinosWrappers::MPI::BlockVector &solution,
+ TrilinosWrappers::MPI::BlockVector &right_hand_side,
const bool eliminate_columns)
{
internal::TrilinosWrappers::apply_block_boundary_values(
{
template <int dim>
PointGeometryData<dim>::PointGeometryData(
- const Point<dim> & new_requested_location,
- const std::vector<Point<dim>> & new_locations,
+ const Point<dim> &new_requested_location,
+ const std::vector<Point<dim>> &new_locations,
const std::vector<types::global_dof_index> &new_sol_indices)
{
requested_location = new_requested_location;
template <int dim>
void
-PointValueHistory<dim>::add_field_name(const std::string & vector_name,
+PointValueHistory<dim>::add_field_name(const std::string &vector_name,
const ComponentMask &mask)
{
// can't be closed to add additional points
template <int dim>
void
PointValueHistory<dim>::add_component_names(
- const std::string & vector_name,
+ const std::string &vector_name,
const std::vector<std::string> &component_names)
{
typename std::map<std::string, std::vector<std::string>>::iterator names =
template <typename VectorType>
void
PointValueHistory<dim>::evaluate_field(const std::string &vector_name,
- const VectorType & solution)
+ const VectorType &solution)
{
// must be closed to add data to internal
// members.
void
PointValueHistory<dim>::evaluate_field(
const std::vector<std::string> &vector_names,
- const VectorType & solution,
- const DataPostprocessor<dim> & data_postprocessor,
- const Quadrature<dim> & quadrature)
+ const VectorType &solution,
+ const DataPostprocessor<dim> &data_postprocessor,
+ const Quadrature<dim> &quadrature)
{
// must be closed to add data to internal
// members.
template <typename VectorType>
void
PointValueHistory<dim>::evaluate_field(
- const std::string & vector_name,
- const VectorType & solution,
+ const std::string &vector_name,
+ const VectorType &solution,
const DataPostprocessor<dim> &data_postprocessor,
- const Quadrature<dim> & quadrature)
+ const Quadrature<dim> &quadrature)
{
std::vector<std::string> vector_names;
vector_names.push_back(vector_name);
void
PointValueHistory<dim>::evaluate_field_at_requested_location(
const std::string &vector_name,
- const VectorType & solution)
+ const VectorType &solution)
{
using number = typename VectorType::value_type;
// must be closed to add data to internal
template <int dim>
void
PointValueHistory<dim>::write_gnuplot(
- const std::string & base_name,
+ const std::string &base_name,
const std::vector<Point<dim>> &postprocessor_locations)
{
AssertThrow(closed, ExcInvalidState());
template <int dim>
void
PointValueHistory<dim>::get_postprocessor_locations(
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
std::vector<Point<dim>> &locations)
{
Assert(!cleared, ExcInvalidState());
template <int dim, int spacedim, typename VectorType>
void
coefficient_decay(FESeries::Legendre<dim, spacedim> &fe_legendre,
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & solution,
- Vector<float> & smoothness_indicators,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &solution,
+ Vector<float> &smoothness_indicators,
const VectorTools::NormType regression_strategy,
const double smallest_abs_coefficient,
const bool only_flagged_cells)
void
coefficient_decay_per_direction(
FESeries::Legendre<dim, spacedim> &fe_legendre,
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & solution,
- Vector<float> & smoothness_indicators,
- const ComponentMask & coefficients_predicate,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &solution,
+ Vector<float> &smoothness_indicators,
+ const ComponentMask &coefficients_predicate,
const double smallest_abs_coefficient,
const bool only_flagged_cells)
{
template <int dim, int spacedim, typename VectorType>
void
coefficient_decay(FESeries::Fourier<dim, spacedim> &fe_fourier,
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & solution,
- Vector<float> & smoothness_indicators,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &solution,
+ Vector<float> &smoothness_indicators,
const VectorTools::NormType regression_strategy,
const double smallest_abs_coefficient,
const bool only_flagged_cells)
void
coefficient_decay_per_direction(
FESeries::Fourier<dim, spacedim> &fe_fourier,
- const DoFHandler<dim, spacedim> & dof_handler,
- const VectorType & solution,
- Vector<float> & smoothness_indicators,
- const ComponentMask & coefficients_predicate,
+ const DoFHandler<dim, spacedim> &dof_handler,
+ const VectorType &solution,
+ Vector<float> &smoothness_indicators,
+ const ComponentMask &coefficients_predicate,
const double smallest_abs_coefficient,
const bool only_flagged_cells)
{
void
SolutionTransfer<dim, VectorType, spacedim>::refine_interpolate(
const VectorType &in,
- VectorType & out) const
+ VectorType &out) const
{
Assert(prepared_for == pure_refinement, ExcNotPrepared());
Assert(in.size() == n_dofs_old, ExcDimensionMismatch(in.size(), n_dofs_old));
*/
template <int dim, int spacedim>
void
- extract_interpolation_matrices(const DoFHandler<dim, spacedim> & dof,
+ extract_interpolation_matrices(const DoFHandler<dim, spacedim> &dof,
dealii::Table<2, FullMatrix<double>> &matrices)
{
if (dof.has_hp_capabilities() == false)
void
SolutionTransfer<dim, VectorType, spacedim>::interpolate(
const std::vector<VectorType> &all_in,
- std::vector<VectorType> & all_out) const
+ std::vector<VectorType> &all_out) const
{
const unsigned int size = all_in.size();
#ifdef DEBUG
void
TimeDependent::insert_timestep(const TimeStepBase *position,
- TimeStepBase * new_timestep)
+ TimeStepBase *new_timestep)
{
Assert((std::find(timesteps.begin(), timesteps.end(), position) !=
timesteps.end()) ||
TimeStepBase_Tria<dim>::TimeStepBase_Tria(
const double time,
const Triangulation<dim> &coarse_grid,
- const Flags & flags,
- const RefinementFlags & refinement_flags)
+ const Flags &flags,
+ const RefinementFlags &refinement_flags)
: TimeStepBase(time)
, tria(nullptr, typeid(*this).name())
, coarse_grid(&coarse_grid, typeid(*this).name())
// which are to be coarsened, we
// raise the limit for these too
if (estimated_cells < previous_cells * (1. - delta_down))
- {
- // number of cells by which the
- // new grid is to be enlarged
- double delta_cells =
- previous_cells * (1. - delta_down) - estimated_cells;
- // heuristics: usually, if we
- // add @p{delta_cells} to the
- // present state, we end up
- // with much more than only
- // (1-delta_down)*prev_cells
- // because of the effect of
- // regularization and because
- // of adaption to the
- // following grid. Therefore,
- // if we are not in the last
- // correction loop, we try not
- // to add as many cells as seem
- // necessary at first and hope
- // to get closer to the limit
- // this way. Only in the last
- // loop do we have to take the
- // full number to guarantee the
- // wanted result.
- //
- // The value 0.9 is taken from
- // practice, as the additional
- // number of cells introduced
- // by regularization is
- // approximately 10 per cent
- // of the flagged cells.
- if (loop != refinement_flags.cell_number_correction_steps - 1)
- delta_cells *= 0.9;
-
- // if more cells need to be
- // refined, we need to lower
- // the thresholds, i.e. to
- // move to the beginning
- // of sorted_criteria, which is
- // sorted in ascending order
- for (unsigned int i = 0; i < delta_cells;
- i += (GeometryInfo<dim>::max_children_per_cell - 1))
- if (p_refinement_threshold != p_coarsening_threshold)
- --refinement_threshold;
- else if (p_coarsening_threshold != sorted_criteria.begin())
- --p_coarsening_threshold, --p_refinement_threshold;
- else
- break;
- }
- else
- // estimated cell number is ok,
- // stop correction steps
- break;
+ {
+ // number of cells by which the
+ // new grid is to be enlarged
+ double delta_cells =
+ previous_cells * (1. - delta_down) - estimated_cells;
+ // heuristics: usually, if we
+ // add @p{delta_cells} to the
+ // present state, we end up
+ // with much more than only
+ // (1-delta_down)*prev_cells
+ // because of the effect of
+ // regularization and because
+ // of adaption to the
+ // following grid. Therefore,
+ // if we are not in the last
+ // correction loop, we try not
+ // to add as many cells as seem
+ // necessary at first and hope
+ // to get closer to the limit
+ // this way. Only in the last
+ // loop do we have to take the
+ // full number to guarantee the
+ // wanted result.
+ //
+ // The value 0.9 is taken from
+ // practice, as the additional
+ // number of cells introduced
+ // by regularization is
+ // approximately 10 per cent
+ // of the flagged cells.
+ if (loop != refinement_flags.cell_number_correction_steps - 1)
+ delta_cells *= 0.9;
+
+ // if more cells need to be
+ // refined, we need to lower
+ // the thresholds, i.e. to
+ // move to the beginning
+ // of sorted_criteria, which is
+ // sorted in ascending order
+ for (unsigned int i = 0; i < delta_cells;
+ i += (GeometryInfo<dim>::max_children_per_cell - 1))
+ if (p_refinement_threshold != p_coarsening_threshold)
+ --refinement_threshold;
+ else if (p_coarsening_threshold != sorted_criteria.begin())
+ --p_coarsening_threshold, --p_refinement_threshold;
+ else
+ break;
+ }
+ else
+ // estimated cell number is ok,
+ // stop correction steps
+ break;
if (p_refinement_threshold == sorted_criteria.end())
{
compute_nonzero_normal_flux_constraints(
const DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int first_vector_component,
- const std::set<types::boundary_id> & boundary_ids,
+ const std::set<types::boundary_id> &boundary_ids,
const std::map<types::boundary_id, const Function<deal_II_dimension> *>
- & function_map,
- AffineConstraints<double> & constraints,
+ &function_map,
+ AffineConstraints<double> &constraints,
const Mapping<deal_II_dimension> &mapping);
template void
compute_nonzero_normal_flux_constraints_on_level(
const DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int first_vector_component,
- const std::set<types::boundary_id> & boundary_ids,
+ const std::set<types::boundary_id> &boundary_ids,
const std::map<types::boundary_id, const Function<deal_II_dimension> *>
- & function_map,
- AffineConstraints<double> & constraints,
+ &function_map,
+ AffineConstraints<double> &constraints,
const Mapping<deal_II_dimension> &mapping,
- const IndexSet & refinement_edge_indices,
+ const IndexSet &refinement_edge_indices,
const unsigned int level);
compute_nonzero_tangential_flux_constraints(
const DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int first_vector_component,
- const std::set<types::boundary_id> & boundary_ids,
+ const std::set<types::boundary_id> &boundary_ids,
const std::map<types::boundary_id, const Function<deal_II_dimension> *>
- & function_map,
- AffineConstraints<double> & constraints,
+ &function_map,
+ AffineConstraints<double> &constraints,
const Mapping<deal_II_dimension> &mapping);
template void
compute_no_normal_flux_constraints(
const DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int first_vector_component,
- const std::set<types::boundary_id> & boundary_ids,
- AffineConstraints<double> & constraints,
- const Mapping<deal_II_dimension> & mapping);
+ const std::set<types::boundary_id> &boundary_ids,
+ AffineConstraints<double> &constraints,
+ const Mapping<deal_II_dimension> &mapping);
template void
compute_no_normal_flux_constraints_on_level(
const DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int first_vector_component,
- const std::set<types::boundary_id> & boundary_ids,
- AffineConstraints<double> & constraints,
- const Mapping<deal_II_dimension> & mapping,
- const IndexSet & refinement_edge_indices,
+ const std::set<types::boundary_id> &boundary_ids,
+ AffineConstraints<double> &constraints,
+ const Mapping<deal_II_dimension> &mapping,
+ const IndexSet &refinement_edge_indices,
const unsigned int level);
template void
compute_normal_flux_constraints(
const DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int first_vector_component,
- const std::set<types::boundary_id> & boundary_ids,
- AffineConstraints<double> & constraints,
- const Mapping<deal_II_dimension> & mapping);
+ const std::set<types::boundary_id> &boundary_ids,
+ AffineConstraints<double> &constraints,
+ const Mapping<deal_II_dimension> &mapping);
# endif
#endif
\}
template void
add_constant(VEC &solution,
const DoFHandler<deal_II_dimension, deal_II_space_dimension>
- & dof_handler,
+ &dof_handler,
const unsigned int component,
const typename VEC::value_type constant_adjustment);
\}
Point<spacedim>
NormalProjectionManifold<dim, spacedim>::project_to_manifold(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Point<spacedim> & candidate) const
+ const Point<spacedim> &candidate) const
{
(void)surrounding_points;
# ifdef DEBUG
/*===================== DirectionalProjectionManifold ======================*/
template <int dim, int spacedim>
DirectionalProjectionManifold<dim, spacedim>::DirectionalProjectionManifold(
- const TopoDS_Shape & sh,
+ const TopoDS_Shape &sh,
const Tensor<1, spacedim> &direction,
const double tolerance)
: sh(sh)
Point<spacedim>
DirectionalProjectionManifold<dim, spacedim>::project_to_manifold(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Point<spacedim> & candidate) const
+ const Point<spacedim> &candidate) const
{
(void)surrounding_points;
# ifdef DEBUG
template <>
Point<3>
internal_project_to_manifold(
- const TopoDS_Shape & sh,
+ const TopoDS_Shape &sh,
const double tolerance,
const ArrayView<const Point<3>> &surrounding_points,
- const Point<3> & candidate)
+ const Point<3> &candidate)
{
constexpr int spacedim = 3;
TopoDS_Shape out_shape;
Point<spacedim>
NormalToMeshProjectionManifold<dim, spacedim>::project_to_manifold(
const ArrayView<const Point<spacedim>> &surrounding_points,
- const Point<spacedim> & candidate) const
+ const Point<spacedim> &candidate) const
{
return internal_project_to_manifold(sh,
tolerance,
TopExp_Explorer exp;
unsigned int n_faces = 0, n_edges = 0, n_vertices = 0;
for (exp.Init(shape, TopAbs_FACE); exp.More(); exp.Next(), ++n_faces)
- {}
+ {
+ }
for (exp.Init(shape, TopAbs_EDGE); exp.More(); exp.Next(), ++n_edges)
- {}
+ {
+ }
for (exp.Init(shape, TopAbs_VERTEX); exp.More(); exp.Next(), ++n_vertices)
- {}
+ {
+ }
return std::tuple<unsigned int, unsigned int, unsigned int>(n_faces,
n_edges,
n_vertices);
}
void
- extract_geometrical_shapes(const TopoDS_Shape & shape,
- std::vector<TopoDS_Face> & faces,
- std::vector<TopoDS_Edge> & edges,
+ extract_geometrical_shapes(const TopoDS_Shape &shape,
+ std::vector<TopoDS_Face> &faces,
+ std::vector<TopoDS_Edge> &edges,
std::vector<TopoDS_Vertex> &vertices)
{
faces.resize(0);
void
- extract_compound_shapes(const TopoDS_Shape & shape,
- std::vector<TopoDS_Compound> & compounds,
+ extract_compound_shapes(const TopoDS_Shape &shape,
+ std::vector<TopoDS_Compound> &compounds,
std::vector<TopoDS_CompSolid> &compsolids,
- std::vector<TopoDS_Solid> & solids,
- std::vector<TopoDS_Shell> & shells,
- std::vector<TopoDS_Wire> & wires)
+ std::vector<TopoDS_Solid> &solids,
+ std::vector<TopoDS_Shell> &shells,
+ std::vector<TopoDS_Wire> &wires)
{
compounds.resize(0);
compsolids.resize(0);
template <int dim>
bool
- point_compare(const Point<dim> & p1,
- const Point<dim> & p2,
+ point_compare(const Point<dim> &p1,
+ const Point<dim> &p2,
const Tensor<1, dim> &direction,
const double tolerance)
{
void
write_STL(const TopoDS_Shape &shape,
- const std::string & filename,
+ const std::string &filename,
const double deflection,
const bool sew_different_faces,
const double sewer_tolerance,
join_edges(const TopoDS_Shape &in_shape, const double tolerance)
{
TopoDS_Edge out_shape;
- const TopoDS_Shape & edges = in_shape;
+ const TopoDS_Shape &edges = in_shape;
std::vector<Handle_Geom_BoundedCurve> intersections;
TopLoc_Location L;
Standard_Real First;
template <int dim>
Point<dim>
- line_intersection(const TopoDS_Shape & in_shape,
- const Point<dim> & origin,
+ line_intersection(const TopoDS_Shape &in_shape,
+ const Point<dim> &origin,
const Tensor<1, dim> &direction,
const double tolerance)
{
template <int dim>
TopoDS_Edge
interpolation_curve(std::vector<Point<dim>> &curve_points,
- const Tensor<1, dim> & direction,
+ const Tensor<1, dim> &direction,
const bool closed,
const double tolerance)
{
std::vector<TopoDS_Edge>
create_curves_from_triangulation_boundary(
const Triangulation<2, spacedim> &triangulation,
- const Mapping<2, spacedim> & mapping)
+ const Mapping<2, spacedim> &mapping)
{
// store maps from global vertex index to pairs of global face indices
template <int dim>
std::tuple<Point<dim>, TopoDS_Shape, double, double>
project_point_and_pull_back(const TopoDS_Shape &in_shape,
- const Point<dim> & origin,
+ const Point<dim> &origin,
const double tolerance)
{
TopExp_Explorer exp;
template <int dim>
Point<dim>
closest_point(const TopoDS_Shape &in_shape,
- const Point<dim> & origin,
+ const Point<dim> &origin,
const double tolerance)
{
std::tuple<Point<dim>, TopoDS_Shape, double, double> ref =
std::tuple<Point<3>, Tensor<1, 3>, double, double>
closest_point_and_differential_forms(const TopoDS_Shape &in_shape,
- const Point<3> & origin,
+ const Point<3> &origin,
const double tolerance)
{
project_point_and_pull_back(in_shape, origin, tolerance);
TopoDS_Shape &out_shape = std::get<1>(shape_and_params);
- double & u = std::get<2>(shape_and_params);
- double & v = std::get<3>(shape_and_params);
+ double &u = std::get<2>(shape_and_params);
+ double &v = std::get<3>(shape_and_params);
// just a check here: the number of faces in out_shape must be 1, otherwise
// something is wrong
template <int spacedim>
void
- create_triangulation(const TopoDS_Face & face,
+ create_triangulation(const TopoDS_Face &face,
Triangulation<2, spacedim> &tria)
{
BRepAdaptor_Surface surf(face);
// Explicit instantiations for dim = 2 and 3
template std::vector<TopoDS_Edge> create_curves_from_triangulation_boundary(
const Triangulation<2, deal_II_dimension> &triangulation,
- const Mapping<2, deal_II_dimension> & mapping);
+ const Mapping<2, deal_II_dimension> &mapping);
- template bool point_compare(const Point<deal_II_dimension> & p1,
- const Point<deal_II_dimension> & p2,
+ template bool point_compare(const Point<deal_II_dimension> &p1,
+ const Point<deal_II_dimension> &p2,
const Tensor<1, deal_II_dimension> &direction,
const double tolerance);
const double v);
template Point<deal_II_dimension> line_intersection(
- const TopoDS_Shape & in_shape,
- const Point<deal_II_dimension> & origin,
+ const TopoDS_Shape &in_shape,
+ const Point<deal_II_dimension> &origin,
const Tensor<1, deal_II_dimension> &direction,
const double tolerance);
const TopoDS_Face &face, Triangulation<2, deal_II_dimension> &tria);
template std::tuple<Point<deal_II_dimension>, TopoDS_Shape, double, double>
- project_point_and_pull_back(const TopoDS_Shape & in_shape,
+ project_point_and_pull_back(const TopoDS_Shape &in_shape,
const Point<deal_II_dimension> &origin,
const double tolerance);
template Point<deal_II_dimension> closest_point(
- const TopoDS_Shape & in_shape,
+ const TopoDS_Shape &in_shape,
const Point<deal_II_dimension> &origin,
const double tolerance);
void
DataOut<dim, spacedim>::build_patches(
const Particles::ParticleHandler<dim, spacedim> &particles,
- const std::vector<std::string> & data_component_names,
+ const std::vector<std::string> &data_component_names,
const std::vector<DataComponentInterpretation::DataComponentInterpretation>
&data_component_interpretations_)
{
std::vector<double>
compute_local_cumulative_cell_weights(
const Triangulation<dim, spacedim> &triangulation,
- const Mapping<dim, spacedim> & mapping,
- const Function<spacedim> & probability_density_function)
+ const Mapping<dim, spacedim> &mapping,
+ const Function<spacedim> &probability_density_function)
{
std::vector<double> cumulative_cell_weights(
triangulation.n_active_cells());
random_location_in_cell(
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
const Mapping<dim, spacedim> &mapping,
- std::mt19937 & random_number_generator)
+ std::mt19937 &random_number_generator)
{
Assert(cell->reference_cell().is_hyper_cube() == true,
ExcNotImplemented());
void
regular_reference_locations(
const Triangulation<dim, spacedim> &triangulation,
- const std::vector<Point<dim>> & particle_reference_locations,
- ParticleHandler<dim, spacedim> & particle_handler,
- const Mapping<dim, spacedim> & mapping)
+ const std::vector<Point<dim>> &particle_reference_locations,
+ ParticleHandler<dim, spacedim> &particle_handler,
+ const Mapping<dim, spacedim> &mapping)
{
types::particle_index particle_index = 0;
types::particle_index n_particles_to_generate =
random_particle_in_cell(
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
const types::particle_index id,
- std::mt19937 & random_number_generator,
+ std::mt19937 &random_number_generator,
const Mapping<dim, spacedim> &mapping)
{
const auto position_and_reference_position =
random_particle_in_cell_insert(
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
const types::particle_index id,
- std::mt19937 & random_number_generator,
+ std::mt19937 &random_number_generator,
ParticleHandler<dim, spacedim> &particle_handler,
- const Mapping<dim, spacedim> & mapping)
+ const Mapping<dim, spacedim> &mapping)
{
const auto position_and_reference_position =
random_location_in_cell(cell, mapping, random_number_generator);
void
probabilistic_locations(
const Triangulation<dim, spacedim> &triangulation,
- const Function<spacedim> & probability_density_function,
+ const Function<spacedim> &probability_density_function,
const bool random_cell_selection,
const types::particle_index n_particles_to_create,
- ParticleHandler<dim, spacedim> & particle_handler,
- const Mapping<dim, spacedim> & mapping,
+ ParticleHandler<dim, spacedim> &particle_handler,
+ const Mapping<dim, spacedim> &mapping,
const unsigned int random_number_seed)
{
unsigned int combined_seed = random_number_seed;
void
dof_support_points(const DoFHandler<dim, spacedim> &dof_handler,
const std::vector<std::vector<BoundingBox<spacedim>>>
- & global_bounding_boxes,
+ &global_bounding_boxes,
ParticleHandler<dim, spacedim> &particle_handler,
- const Mapping<dim, spacedim> & mapping,
- const ComponentMask & components,
+ const Mapping<dim, spacedim> &mapping,
+ const ComponentMask &components,
const std::vector<std::vector<double>> &properties)
{
const auto &fe = dof_handler.get_fe();
void
quadrature_points(
const Triangulation<dim, spacedim> &triangulation,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
// const std::vector<Point<dim>> & particle_reference_locations,
const std::vector<std::vector<BoundingBox<spacedim>>>
- & global_bounding_boxes,
- ParticleHandler<dim, spacedim> & particle_handler,
- const Mapping<dim, spacedim> & mapping,
+ &global_bounding_boxes,
+ ParticleHandler<dim, spacedim> &particle_handler,
+ const Mapping<dim, spacedim> &mapping,
const std::vector<std::vector<double>> &properties)
{
const std::vector<Point<dim>> &particle_reference_locations =
template void
probabilistic_locations<deal_II_dimension, deal_II_space_dimension>(
const Triangulation<deal_II_dimension, deal_II_space_dimension>
- & triangulation,
+ &triangulation,
const Function<deal_II_space_dimension> &probability_density_function,
const bool random_cell_selection,
const types::particle_index n_particles_to_create,
ParticleHandler<deal_II_dimension, deal_II_space_dimension>
&particle_handler,
const Mapping<deal_II_dimension, deal_II_space_dimension> &mapping,
- const ComponentMask & components,
+ const ComponentMask &components,
const std::vector<std::vector<double>> &properties);
template void
quadrature_points<deal_II_dimension, deal_II_space_dimension>(
const Triangulation<deal_II_dimension, deal_II_space_dimension>
- & particle_tria,
+ &particle_tria,
const Quadrature<deal_II_dimension> &quadrature,
const std::vector<std::vector<BoundingBox<deal_II_space_dimension>>>
&global_bounding_boxes,
template <int dim, int spacedim>
Particle<dim, spacedim>::Particle(const Point<spacedim> &location,
- const Point<dim> & reference_location,
+ const Point<dim> &reference_location,
const types::particle_index id)
: property_pool(&global_property_pool)
, property_pool_handle(property_pool->register_particle())
template <int dim, int spacedim>
Particle<dim, spacedim>::Particle(
- const void *& data,
+ const void *&data,
PropertyPool<dim, spacedim> *const new_property_pool)
: property_pool(new_property_pool != nullptr ? new_property_pool :
&global_property_pool)
template <int dim, int spacedim>
ParticleHandler<dim, spacedim>::ParticleHandler(
const Triangulation<dim, spacedim> &triangulation,
- const Mapping<dim, spacedim> & mapping,
+ const Mapping<dim, spacedim> &mapping,
const unsigned int n_properties)
: triangulation(&triangulation, typeid(*this).name())
, mapping(&mapping, typeid(*this).name())
void
ParticleHandler<dim, spacedim>::initialize(
const Triangulation<dim, spacedim> &new_triangulation,
- const Mapping<dim, spacedim> & new_mapping,
+ const Mapping<dim, spacedim> &new_mapping,
const unsigned int n_properties)
{
clear();
template <int dim, int spacedim>
typename ParticleHandler<dim, spacedim>::particle_iterator
ParticleHandler<dim, spacedim>::insert_particle(
- const Particle<dim, spacedim> & particle,
+ const Particle<dim, spacedim> &particle,
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell)
{
return insert_particle(particle.get_location(),
template <int dim, int spacedim>
typename ParticleHandler<dim, spacedim>::particle_iterator
ParticleHandler<dim, spacedim>::insert_particle(
- const void *& data,
+ const void *&data,
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell)
{
Assert(triangulation != nullptr, ExcInternalError());
template <int dim, int spacedim>
typename ParticleHandler<dim, spacedim>::particle_iterator
ParticleHandler<dim, spacedim>::insert_particle(
- const Point<spacedim> & position,
- const Point<dim> & reference_position,
+ const Point<spacedim> &position,
+ const Point<dim> &reference_position,
const types::particle_index particle_index,
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
const ArrayView<const double> &properties)
ParticleHandler<dim, spacedim>::insert_global_particles(
const std::vector<Point<spacedim>> &positions,
const std::vector<std::vector<BoundingBox<spacedim>>>
- & global_bounding_boxes,
- const std::vector<std::vector<double>> & properties,
+ &global_bounding_boxes,
+ const std::vector<std::vector<double>> &properties,
const std::vector<types::particle_index> &ids)
{
if (!properties.empty())
compare_particle_association(
const unsigned int a,
const unsigned int b,
- const Tensor<1, dim> & particle_direction,
+ const Tensor<1, dim> &particle_direction,
const std::vector<Tensor<1, dim>> ¢er_directions)
{
const double scalar_product_a = center_directions[a] * particle_direction;
const std::map<
types::subdomain_id,
std::vector<typename Triangulation<dim, spacedim>::active_cell_iterator>>
- & send_cells,
+ &send_cells,
const bool build_cache)
{
Assert(triangulation != nullptr, ExcInternalError());
template <int dim, int spacedim>
void
ParticleHandler<dim, spacedim>::register_additional_store_load_functions(
- const std::function<std::size_t()> & size_callb,
+ const std::function<std::size_t()> &size_callb,
const std::function<void *(const particle_iterator &, void *)> &store_callb,
const std::function<const void *(const particle_iterator &, const void *)>
&load_callb)
const auto callback_function =
[this](const typename Triangulation<dim, spacedim>::cell_iterator
- & cell_iterator,
+ &cell_iterator,
const CellStatus cell_status) {
return this->pack_callback(cell_iterator, cell_status);
};
{
const auto callback_function =
[this](const typename Triangulation<dim, spacedim>::cell_iterator
- & cell_iterator,
+ &cell_iterator,
const CellStatus cell_status,
const boost::iterator_range<std::vector<char>::const_iterator>
&range_iterator) {
template <int dim, int spacedim>
void
ParticleHandler<dim, spacedim>::unpack_callback(
- const typename Triangulation<dim, spacedim>::cell_iterator & cell,
+ const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator> &data_range)
{
template <int dim, int spacedim, typename number>
void
create_interpolation_sparsity_pattern(
- const DoFHandler<dim, spacedim> & space_dh,
+ const DoFHandler<dim, spacedim> &space_dh,
const Particles::ParticleHandler<dim, spacedim> &particle_handler,
- SparsityPatternBase & sparsity,
- const AffineConstraints<number> & constraints,
- const ComponentMask & space_comps)
+ SparsityPatternBase &sparsity,
+ const AffineConstraints<number> &constraints,
+ const ComponentMask &space_comps)
{
if (particle_handler.n_locally_owned_particles() == 0)
return; // nothing to do here
template <int dim, int spacedim, typename MatrixType>
void
create_interpolation_matrix(
- const DoFHandler<dim, spacedim> & space_dh,
+ const DoFHandler<dim, spacedim> &space_dh,
const Particles::ParticleHandler<dim, spacedim> &particle_handler,
- MatrixType & matrix,
+ MatrixType &matrix,
const AffineConstraints<typename MatrixType::value_type> &constraints,
- const ComponentMask & space_comps)
+ const ComponentMask &space_comps)
{
if (particle_handler.n_locally_owned_particles() == 0)
{
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &space_dh,
const Particles::ParticleHandler<deal_II_dimension,
deal_II_space_dimension>
- & particle_handler,
- SparsityPatternBase & sparsity,
+ &particle_handler,
+ SparsityPatternBase &sparsity,
const AffineConstraints<scalar> &constraints,
- const ComponentMask & space_comps);
+ const ComponentMask &space_comps);
#endif
}
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &space_dh,
const Particles::ParticleHandler<deal_II_dimension,
deal_II_space_dimension>
- & particle_handler,
- Matrix & matrix,
+ &particle_handler,
+ Matrix &matrix,
const AffineConstraints<Matrix::value_type> &constraints,
- const ComponentMask & space_comps);
+ const ComponentMask &space_comps);
#endif
}
template <typename VectorType>
unsigned int
- ARKode<VectorType>::solve_ode_incrementally(VectorType & solution,
+ ARKode<VectorType>::solve_ode_incrementally(VectorType &solution,
const double intermediate_time,
const bool reset_solver)
{
template <typename VectorType>
int
- ARKode<VectorType>::do_evolve_time(VectorType & solution,
+ ARKode<VectorType>::do_evolve_time(VectorType &solution,
DiscreteTime &time,
const bool do_reset)
{
realtype t,
N_Vector y,
N_Vector fy,
- void * user_data,
+ void *user_data,
N_Vector) -> int {
Assert(user_data != nullptr, ExcInternalError());
ARKode<VectorType> &solver =
realtype gamma,
realtype delta,
int lr,
- void * user_data) -> int {
+ void *user_data) -> int {
Assert(user_data != nullptr, ExcInternalError());
ARKode<VectorType> &solver =
*static_cast<ARKode<VectorType> *>(user_data);
void
IDA<VectorType>::reset(const double current_time,
const double current_time_step,
- VectorType & solution,
- VectorType & solution_dot)
+ VectorType &solution,
+ VectorType &solution_dot)
{
bool first_step = (current_time == data.initial_time);
SUNContext
#endif
);
- template V<S> * SUNDIALS::internal::unwrap_nvector<V<S>>(N_Vector);
+ template V<S> *SUNDIALS::internal::unwrap_nvector<V<S>>(N_Vector);
template const V<S> *SUNDIALS::internal::unwrap_nvector_const<V<S>>(
N_Vector);
*/
template <typename F, typename... Args>
int
- call_and_possibly_capture_exception(const F & f,
+ call_and_possibly_capture_exception(const F &f,
std::exception_ptr &eptr,
Args &&...args)
{
- SUNLinearSolver_Type arkode_linsol_get_type(SUNLinearSolver)
+ SUNLinearSolver_Type
+ arkode_linsol_get_type(SUNLinearSolver)
{
return SUNLINEARSOLVER_ITERATIVE;
}
template <typename VectorType>
- int arkode_linsol_initialize(SUNLinearSolver)
+ int
+ arkode_linsol_initialize(SUNLinearSolver)
{
// this method is currently only provided because SUNDIALS 4.0.0 requires
// it - no user-set action is implemented so far
template <typename VectorType>
int
arkode_linsol_set_preconditioner(SUNLinearSolver LS,
- void * P_data,
+ void *P_data,
PSetupFn p_setup,
PSolveFn p_solve)
{
template <typename VectorType>
internal::LinearSolverWrapper<VectorType>::LinearSolverWrapper(
const LinearSolveFunction<VectorType> &lsolve,
- std::exception_ptr & pending_exception
+ std::exception_ptr &pending_exception
# if DEAL_II_SUNDIALS_VERSION_GTE(6, 0, 0)
,
SUNContext linsol_ctx
# if DEAL_II_SUNDIALS_VERSION_GTE(6, 0, 0)
template <typename VectorType>
- SundialsOperator<VectorType>::SundialsOperator(void * A_data,
+ SundialsOperator<VectorType>::SundialsOperator(void *A_data,
ATimesFn a_times_fn,
SUNContext linsol_ctx)
: A_data(A_data)
}
# else
template <typename VectorType>
- SundialsOperator<VectorType>::SundialsOperator(void *A_data,
+ SundialsOperator<VectorType>::SundialsOperator(void *A_data,
ATimesFn a_times_fn)
: A_data(A_data)
, a_times_fn(a_times_fn)
template <typename VectorType>
void
- SundialsOperator<VectorType>::vmult(VectorType & dst,
+ SundialsOperator<VectorType>::vmult(VectorType &dst,
const VectorType &src) const
{
auto sun_dst = internal::make_nvector_view(dst
# if DEAL_II_SUNDIALS_VERSION_GTE(6, 0, 0)
template <typename VectorType>
SundialsPreconditioner<VectorType>::SundialsPreconditioner(
- void * P_data,
+ void *P_data,
PSolveFn p_solve_fn,
SUNContext linsol_ctx,
double tol)
# else
template <typename VectorType>
SundialsPreconditioner<VectorType>::SundialsPreconditioner(
- void *P_data,
+ void *P_data,
PSolveFn p_solve_fn,
- double tol)
+ double tol)
: P_data(P_data)
, p_solve_fn(p_solve_fn)
, tol(tol)
template <typename VectorType>
void
- SundialsPreconditioner<VectorType>::vmult(VectorType & dst,
+ SundialsPreconditioner<VectorType>::vmult(VectorType &dst,
const VectorType &src) const
{
// apply identity preconditioner if nothing else specified
static NumberType
psi(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return pow(det_t(t), 2) * pow(v_squ(v), 3);
};
static SymmetricTensor<2, dim, NumberType>
dpsi_dt(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return SymmetricTensor<2, dim, NumberType>(2.0 * pow(det_t(t), 1) *
ddet_t_dt(t) * pow(v_squ(v), 3));
static Tensor<1, dim, NumberType>
dpsi_dv(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return pow(det_t(t), 2) * 3.0 * pow(v_squ(v), 2) * dv_squ_dv(v);
};
static SymmetricTensor<4, dim, NumberType>
d2psi_dt_dt(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return SymmetricTensor<4, dim, NumberType>(
2.0 * pow(v_squ(v), 3) *
static Tensor<3, dim, NumberType>
d2psi_dv_dt(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return 2.0 * pow(det_t(t), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(static_cast<Tensor<2, dim, NumberType>>(ddet_t_dt(t)),
static Tensor<3, dim, NumberType>
d2psi_dt_dv(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return 2.0 * pow(det_t(t), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(dv_squ_dv(v),
static Tensor<2, dim, NumberType>
d2psi_dv_dv(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return pow(det_t(t), 2) * 3.0 *
(2.0 * pow(v_squ(v), 1) * outer_product(dv_squ_dv(v), dv_squ_dv(v)) +
static NumberType
psi(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return pow(det_t(t), 2) * pow(v_squ(v), 3);
};
static SymmetricTensor<2, dim, NumberType>
dpsi_dt(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return SymmetricTensor<2, dim, NumberType>(2.0 * pow(det_t(t), 1) *
ddet_t_dt(t) * pow(v_squ(v), 3));
static Tensor<1, dim, NumberType>
dpsi_dv(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return pow(det_t(t), 2) * 3.0 * pow(v_squ(v), 2) * dv_squ_dv(v);
};
static SymmetricTensor<4, dim, NumberType>
d2psi_dt_dt(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return SymmetricTensor<4, dim, NumberType>(
2.0 * pow(v_squ(v), 3) *
static Tensor<3, dim, NumberType>
d2psi_dv_dt(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return 2.0 * pow(det_t(t), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(static_cast<Tensor<2, dim, NumberType>>(ddet_t_dt(t)),
static Tensor<3, dim, NumberType>
d2psi_dt_dv(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return 2.0 * pow(det_t(t), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(dv_squ_dv(v),
static Tensor<2, dim, NumberType>
d2psi_dv_dv(const SymmetricTensor<2, dim, NumberType> &t,
- const Tensor<1, dim, NumberType> & v)
+ const Tensor<1, dim, NumberType> &v)
{
return pow(det_t(t), 2) * 3.0 *
(2.0 * pow(v_squ(v), 1) * outer_product(dv_squ_dv(v), dv_squ_dv(v)) +
static NumberType
psi(const SymmetricTensor<2, dim, NumberType> &t1,
- const Tensor<2, dim, NumberType> & t2)
+ const Tensor<2, dim, NumberType> &t2)
{
return pow(det_t(t1), 2) * pow(det_t(t2), 3);
};
static SymmetricTensor<2, dim, NumberType>
dpsi_dt1(const SymmetricTensor<2, dim, NumberType> &t1,
- const Tensor<2, dim, NumberType> & t2)
+ const Tensor<2, dim, NumberType> &t2)
{
return SymmetricTensor<2, dim, NumberType>(
2.0 * pow(det_t(t1), 1) * ddet_t_dt(t1) * pow(det_t(t2), 3));
static Tensor<2, dim, NumberType>
dpsi_dt2(const SymmetricTensor<2, dim, NumberType> &t1,
- const Tensor<2, dim, NumberType> & t2)
+ const Tensor<2, dim, NumberType> &t2)
{
return pow(det_t(t1), 2) * 3.0 * pow(det_t(t2), 2) * ddet_t_dt(t2);
};
static SymmetricTensor<4, dim, NumberType>
d2psi_dt1_dt1(const SymmetricTensor<2, dim, NumberType> &t1,
- const Tensor<2, dim, NumberType> & t2)
+ const Tensor<2, dim, NumberType> &t2)
{
return SymmetricTensor<4, dim, NumberType>(
2.0 * pow(det_t(t2), 3) *
static Tensor<4, dim, NumberType>
d2psi_dt2_dt1(const SymmetricTensor<2, dim, NumberType> &t1,
- const Tensor<2, dim, NumberType> & t2)
+ const Tensor<2, dim, NumberType> &t2)
{
return 2.0 * pow(det_t(t1), 1) * 3.0 * pow(det_t(t2), 2) *
outer_product(static_cast<Tensor<2, dim, NumberType>>(ddet_t_dt(t1)),
static Tensor<4, dim, NumberType>
d2psi_dt1_dt2(const SymmetricTensor<2, dim, NumberType> &t1,
- const Tensor<2, dim, NumberType> & t2)
+ const Tensor<2, dim, NumberType> &t2)
{
return 2.0 * pow(det_t(t1), 1) * 3.0 * pow(det_t(t2), 2) *
outer_product(ddet_t_dt(t2),
static Tensor<4, dim, NumberType>
d2psi_dt2_dt2(const SymmetricTensor<2, dim, NumberType> &t1,
- const Tensor<2, dim, NumberType> & t2)
+ const Tensor<2, dim, NumberType> &t2)
{
return pow(det_t(t1), 2) * 3.0 *
(2.0 * pow(det_t(t2), 1) *
static NumberType
psi(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * pow(v_squ(v), 3) * pow(s, sf);
};
static Tensor<2, dim, NumberType>
dpsi_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 1) * ddet_t_dt(t) * pow(v_squ(v), 3) *
pow(s, sf);
static Tensor<1, dim, NumberType>
dpsi_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * 3.0 * pow(v_squ(v), 2) * dv_squ_dv(v) *
pow(s, sf);
static NumberType
dpsi_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * pow(v_squ(v), 3) * sf * pow(s, sf - 1.0);
};
static Tensor<4, dim, NumberType>
d2psi_dt_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(v_squ(v), 3) *
(pow(det_t(t), 0) * outer_product(ddet_t_dt(t), ddet_t_dt(t)) +
static Tensor<3, dim, NumberType>
d2psi_dv_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(ddet_t_dt(t), dv_squ_dv(v)) * pow(s, sf);
static Tensor<2, dim, NumberType>
d2psi_ds_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 1) * ddet_t_dt(t) * pow(v_squ(v), 3) * sf *
pow(s, sf - 1.0);
static Tensor<3, dim, NumberType>
d2psi_dt_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(dv_squ_dv(v), ddet_t_dt(t)) * pow(s, sf);
static Tensor<2, dim, NumberType>
d2psi_dv_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * 3.0 *
(2.0 * pow(v_squ(v), 1) * outer_product(dv_squ_dv(v), dv_squ_dv(v)) +
static Tensor<1, dim, NumberType>
d2psi_ds_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * 3.0 * pow(v_squ(v), 2) * dv_squ_dv(v) * sf *
pow(s, sf - 1.0);
static Tensor<2, dim, NumberType>
d2psi_dt_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 1) * ddet_t_dt(t) * pow(v_squ(v), 3) * sf *
pow(s, sf - 1.0);
static Tensor<1, dim, NumberType>
d2psi_dv_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * 3.0 * pow(v_squ(v), 2) * dv_squ_dv(v) * sf *
pow(s, sf - 1.0);
static NumberType
d2psi_ds_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * pow(v_squ(v), 3) * sf * (sf - 1.0) *
pow(s, sf - 2.0);
static NumberType
psi(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * pow(v_squ(v), 3) * pow(s, sf);
};
static Tensor<2, dim, NumberType>
dpsi_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 1) * ddet_t_dt(t) * pow(v_squ(v), 3) *
pow(s, sf);
static Tensor<1, dim, NumberType>
dpsi_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * 3.0 * pow(v_squ(v), 2) * dv_squ_dv(v) *
pow(s, sf);
static NumberType
dpsi_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * pow(v_squ(v), 3) * sf * pow(s, sf - 1.0);
};
static Tensor<4, dim, NumberType>
d2psi_dt_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(v_squ(v), 3) *
(pow(det_t(t), 0) * outer_product(ddet_t_dt(t), ddet_t_dt(t)) +
static Tensor<3, dim, NumberType>
d2psi_dv_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(ddet_t_dt(t), dv_squ_dv(v)) * pow(s, sf);
static Tensor<2, dim, NumberType>
d2psi_ds_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 1) * ddet_t_dt(t) * pow(v_squ(v), 3) * sf *
pow(s, sf - 1.0);
static Tensor<3, dim, NumberType>
d2psi_dt_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(dv_squ_dv(v), ddet_t_dt(t)) * pow(s, sf);
static Tensor<2, dim, NumberType>
d2psi_dv_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * 3.0 *
(2.0 * pow(v_squ(v), 1) * outer_product(dv_squ_dv(v), dv_squ_dv(v)) +
static Tensor<1, dim, NumberType>
d2psi_ds_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * 3.0 * pow(v_squ(v), 2) * dv_squ_dv(v) * sf *
pow(s, sf - 1.0);
static Tensor<2, dim, NumberType>
d2psi_dt_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 1) * ddet_t_dt(t) * pow(v_squ(v), 3) * sf *
pow(s, sf - 1.0);
static Tensor<1, dim, NumberType>
d2psi_dv_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * 3.0 * pow(v_squ(v), 2) * dv_squ_dv(v) * sf *
pow(s, sf - 1.0);
static NumberType
d2psi_ds_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return pow(det_t(t), 2) * pow(v_squ(v), 3) * sf * (sf - 1.0) *
pow(s, sf - 2.0);
static NumberType
psi(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return pow(det_t(st), 2) * pow(det_t(t), 2) * pow(v_squ(v), 3) * pow(s, sf);
};
static SymmetricTensor<2, dim, NumberType>
dpsi_dst(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * pow(det_t(st), 1) * ddet_t_dt(st) * pow(det_t(t), 2) *
pow(v_squ(v), 3) * pow(s, sf);
static Tensor<2, dim, NumberType>
dpsi_dt(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * pow(det_t(st), 2) * pow(det_t(t), 1) * ddet_t_dt(t) *
pow(v_squ(v), 3) * pow(s, sf);
static Tensor<1, dim, NumberType>
dpsi_dv(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return pow(det_t(st), 2) * pow(det_t(t), 2) * 3.0 * pow(v_squ(v), 2) *
dv_squ_dv(v) * pow(s, sf);
static NumberType
dpsi_ds(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return pow(det_t(st), 2) * pow(det_t(t), 2) * pow(v_squ(v), 3) * sf *
pow(s, sf - 1.0);
static SymmetricTensor<4, dim, NumberType>
d2psi_dst_x_dst(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 2) * pow(v_squ(v), 3) *
(pow(det_t(st), 0) * outer_product(ddet_t_dt(st), ddet_t_dt(st)) +
static Tensor<4, dim, NumberType>
d2psi_dst_x_dt(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 4.0 * pow(det_t(st), 1) * pow(det_t(t), 1) *
outer_product(Tensor<2, dim, NumberType>(ddet_t_dt(st)),
static Tensor<3, dim, NumberType>
d2psi_dst_x_dv(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 2) * pow(det_t(st), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(Tensor<2, dim, NumberType>(ddet_t_dt(st)),
static SymmetricTensor<2, dim, NumberType>
d2psi_dst_x_ds(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * pow(det_t(st), 1) * ddet_t_dt(st) * pow(det_t(t), 2) *
pow(v_squ(v), 3) * sf * pow(s, sf - 1.0);
static Tensor<4, dim, NumberType>
d2psi_dt_x_dst(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 4.0 * pow(det_t(st), 1) * pow(det_t(t), 1) *
outer_product(ddet_t_dt(t),
static Tensor<4, dim, NumberType>
d2psi_dt_x_dt(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * pow(det_t(st), 2) * pow(v_squ(v), 3) *
(pow(det_t(t), 0) * outer_product(ddet_t_dt(t), ddet_t_dt(t)) +
static Tensor<3, dim, NumberType>
d2psi_dt_x_dv(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * pow(det_t(st), 2) * pow(det_t(t), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(ddet_t_dt(t), dv_squ_dv(v)) * pow(s, sf);
static Tensor<2, dim, NumberType>
d2psi_dt_x_ds(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * pow(det_t(st), 2) * pow(det_t(t), 1) * ddet_t_dt(t) *
pow(v_squ(v), 3) * sf * pow(s, sf - 1.0);
static Tensor<3, dim, NumberType>
d2psi_dv_x_dst(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * pow(det_t(t), 2) * pow(det_t(st), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(dv_squ_dv(v),
static Tensor<3, dim, NumberType>
d2psi_dv_x_dt(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * pow(det_t(st), 2) * pow(det_t(t), 1) * 3.0 * pow(v_squ(v), 2) *
outer_product(dv_squ_dv(v), ddet_t_dt(t)) * pow(s, sf);
static Tensor<2, dim, NumberType>
d2psi_dv_x_dv(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return pow(det_t(st), 2) * pow(det_t(t), 2) * 3.0 *
(2.0 * pow(v_squ(v), 1) * outer_product(dv_squ_dv(v), dv_squ_dv(v)) +
static Tensor<1, dim, NumberType>
d2psi_dv_x_ds(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return pow(det_t(st), 2) * pow(det_t(t), 2) * 3.0 * pow(v_squ(v), 2) *
dv_squ_dv(v) * sf * pow(s, sf - 1.0);
static SymmetricTensor<2, dim, NumberType>
d2psi_ds_x_dst(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * ddet_t_dt(st) * pow(det_t(t), 2) * pow(det_t(st), 1) *
pow(v_squ(v), 3) * sf * pow(s, sf - 1.0);
static Tensor<2, dim, NumberType>
d2psi_ds_x_dt(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * pow(det_t(st), 2) * pow(det_t(t), 1) * ddet_t_dt(t) *
pow(v_squ(v), 3) * sf * pow(s, sf - 1.0);
static Tensor<1, dim, NumberType>
d2psi_ds_x_dv(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return pow(det_t(st), 2) * pow(det_t(t), 2) * 3.0 * pow(v_squ(v), 2) *
dv_squ_dv(v) * sf * pow(s, sf - 1.0);
static NumberType
d2psi_ds_x_ds(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return pow(det_t(st), 2) * pow(det_t(t), 2) * pow(v_squ(v), 3) * sf *
(sf - 1.0) * pow(s, sf - 2.0);
static const SymmetricTensor<4, dim> dev_P;
};
template <int dim>
- const SymmetricTensor<2, dim>
- StandardTensors<dim>::I = unit_symmetric_tensor<dim>();
+ const SymmetricTensor<2, dim> StandardTensors<dim>::I =
+ unit_symmetric_tensor<dim>();
template <int dim>
const SymmetricTensor<4, dim> StandardTensors<dim>::IxI = outer_product(I, I);
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::II = identity_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::II =
+ identity_tensor<dim>();
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::dev_P = deviator_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::dev_P =
+ deviator_tensor<dim>();
class Time
{
public:
template <typename NumberType>
SymmetricTensor<2, dim, NumberType>
get_tau(const Tensor<2, dim, NumberType> &F,
- const NumberType & p_tilde) const
+ const NumberType &p_tilde) const
{
return get_tau_iso(F) + get_tau_vol(F, p_tilde);
}
template <typename NumberType>
SymmetricTensor<2, dim, NumberType>
get_tau_vol(const Tensor<2, dim, NumberType> &F,
- const NumberType & p_tilde) const
+ const NumberType &p_tilde) const
{
const NumberType det_F = determinant(F);
// return p_tilde * det_F * StandardTensors<dim>::I;
template <typename NumberType>
SymmetricTensor<2, dim, NumberType>
get_tau(const Tensor<2, dim, NumberType> &F,
- const NumberType & p_tilde) const
+ const NumberType &p_tilde) const
{
return material->get_tau(F, p_tilde);
}
void
assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_ASM & scratch,
- PerTaskData_ASM & data) const;
+ ScratchData_ASM &scratch,
+ PerTaskData_ASM &data) const;
void
copy_local_to_global_system(const PerTaskData_ASM &data);
void
void
assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void
copy_local_to_global_sc(const PerTaskData_SC &data);
void
get_error_residual(Errors &error_residual);
void
get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double>
get_error_dilation(const BlockVector<double> &solution_total) const;
void
const BlockVector<double> &solution_total;
FEValues<dim> fe_values_ref;
FEFaceValues<dim> fe_face_values_ref;
- ScratchData_ASM(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_ASM(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
void
Solid<dim, number_t, ad_type_code>::get_error_update(
const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler_ref.n_dofs(); ++i)
void
Solid<dim, number_t, ad_type_code>::assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_ASM & scratch,
- PerTaskData_ASM & data) const
+ ScratchData_ASM &scratch,
+ PerTaskData_ASM &data) const
{
data.reset();
scratch.reset();
void
Solid<dim, number_t, ad_type_code>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
const Vector<double> &f_u = system_rhs.block(u_dof);
const Vector<double> &f_p = system_rhs.block(p_dof);
const Vector<double> &f_J = system_rhs.block(J_dof);
- Vector<double> & d_u = newton_update.block(u_dof);
- Vector<double> & d_p = newton_update.block(p_dof);
- Vector<double> & d_J = newton_update.block(J_dof);
+ Vector<double> &d_u = newton_update.block(u_dof);
+ Vector<double> &d_p = newton_update.block(p_dof);
+ Vector<double> &d_J = newton_update.block(J_dof);
const auto K_uu =
linear_operator(tangent_matrix.block(u_dof, u_dof));
const auto K_up =
static const SymmetricTensor<4, dim> dev_P;
};
template <int dim>
- const SymmetricTensor<2, dim>
- StandardTensors<dim>::I = unit_symmetric_tensor<dim>();
+ const SymmetricTensor<2, dim> StandardTensors<dim>::I =
+ unit_symmetric_tensor<dim>();
template <int dim>
const SymmetricTensor<4, dim> StandardTensors<dim>::IxI = outer_product(I, I);
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::II = identity_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::II =
+ identity_tensor<dim>();
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::dev_P = deviator_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::dev_P =
+ deviator_tensor<dim>();
class Time
{
public:
void
assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const;
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const;
void
copy_local_to_global_K(const PerTaskData_K &data);
void
void
assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const;
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const;
void
copy_local_to_global_rhs(const PerTaskData_RHS &data);
void
void
assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void
copy_local_to_global_sc(const PerTaskData_SC &data);
void
void
update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
- PerTaskData_UQPH & data);
+ ScratchData_UQPH &scratch,
+ PerTaskData_UQPH &data);
void
copy_local_to_global_UQPH(const PerTaskData_UQPH & /*data*/)
{}
get_error_residual(Errors &error_residual);
void
get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double>
get_error_dilation() const;
double
std::vector<std::vector<Tensor<2, dim>>> grad_Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_K(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, Nx(qf_cell.size(), std::vector<double>(fe_cell.dofs_per_cell))
std::vector<std::vector<double>> Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_RHS(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, fe_face_values_ref(fe_cell, qf_face, uf_face)
template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
struct Solid<dim, number_t, ad_type_code>::ScratchData_UQPH
{
- const BlockVector<double> & solution_total;
+ const BlockVector<double> &solution_total;
std::vector<Tensor<2, dim>> solution_grads_u_total;
std::vector<double> solution_values_p_total;
std::vector<double> solution_values_J_total;
FEValues<dim> fe_values_ref;
- ScratchData_UQPH(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_UQPH(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
void
Solid<dim, number_t, ad_type_code>::update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
+ ScratchData_UQPH &scratch,
PerTaskData_UQPH & /*data*/)
{
const std::vector<
void
Solid<dim, number_t, ad_type_code>::get_error_update(
const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler_ref.n_dofs(); ++i)
void
Solid<dim, number_t, ad_type_code>::assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const
{
data.reset();
scratch.reset();
const SymmetricTensor<4, dim> Jc = lqph[q_point]->get_Jc();
const double d2Psi_vol_dJ2 = lqph[q_point]->get_d2Psi_vol_dJ2();
const double det_F = lqph[q_point]->get_det_F();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const std::vector<Tensor<2, dim>> &grad_Nx = scratch.grad_Nx[q_point];
void
Solid<dim, number_t, ad_type_code>::assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const
{
data.reset();
scratch.reset();
const double J_tilde = lqph[q_point]->get_J_tilde();
const double p_tilde = lqph[q_point]->get_p_tilde();
const double dPsi_vol_dJ = lqph[q_point]->get_dPsi_vol_dJ();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const double JxW = scratch.fe_values_ref.JxW(q_point);
void
Solid<dim, number_t, ad_type_code>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
const Vector<double> &f_u = system_rhs.block(u_dof);
const Vector<double> &f_p = system_rhs.block(p_dof);
const Vector<double> &f_J = system_rhs.block(J_dof);
- Vector<double> & d_u = newton_update.block(u_dof);
- Vector<double> & d_p = newton_update.block(p_dof);
- Vector<double> & d_J = newton_update.block(J_dof);
+ Vector<double> &d_u = newton_update.block(u_dof);
+ Vector<double> &d_p = newton_update.block(p_dof);
+ Vector<double> &d_J = newton_update.block(J_dof);
const auto K_uu =
linear_operator(tangent_matrix.block(u_dof, u_dof));
const auto K_up =
static const SymmetricTensor<4, dim> dev_P;
};
template <int dim>
- const SymmetricTensor<2, dim>
- StandardTensors<dim>::I = unit_symmetric_tensor<dim>();
+ const SymmetricTensor<2, dim> StandardTensors<dim>::I =
+ unit_symmetric_tensor<dim>();
template <int dim>
const SymmetricTensor<4, dim> StandardTensors<dim>::IxI = outer_product(I, I);
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::II = identity_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::II =
+ identity_tensor<dim>();
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::dev_P = deviator_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::dev_P =
+ deviator_tensor<dim>();
class Time
{
public:
template <typename NumberType>
NumberType
get_Psi(const Tensor<2, dim, NumberType> &F,
- const NumberType & p_tilde,
- const NumberType & J_tilde) const
+ const NumberType &p_tilde,
+ const NumberType &J_tilde) const
{
const SymmetricTensor<2, dim, NumberType> C =
symmetrize(transpose(F) * F);
void
assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_ASM & scratch,
- PerTaskData_ASM & data) const;
+ ScratchData_ASM &scratch,
+ PerTaskData_ASM &data) const;
void
copy_local_to_global_system(const PerTaskData_ASM &data);
void
void
assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void
copy_local_to_global_sc(const PerTaskData_SC &data);
void
get_error_residual(Errors &error_residual);
void
get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double>
get_error_dilation(const BlockVector<double> &solution_total) const;
void
const BlockVector<double> &solution_total;
FEValues<dim> fe_values_ref;
FEFaceValues<dim> fe_face_values_ref;
- ScratchData_ASM(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_ASM(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
void
Solid<dim, number_t, ad_type_code>::get_error_update(
const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler_ref.n_dofs(); ++i)
void
Solid<dim, number_t, ad_type_code>::assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_ASM & scratch,
- PerTaskData_ASM & data) const
+ ScratchData_ASM &scratch,
+ PerTaskData_ASM &data) const
{
data.reset();
scratch.reset();
void
Solid<dim, number_t, ad_type_code>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
const Vector<double> &f_u = system_rhs.block(u_dof);
const Vector<double> &f_p = system_rhs.block(p_dof);
const Vector<double> &f_J = system_rhs.block(J_dof);
- Vector<double> & d_u = newton_update.block(u_dof);
- Vector<double> & d_p = newton_update.block(p_dof);
- Vector<double> & d_J = newton_update.block(J_dof);
+ Vector<double> &d_u = newton_update.block(u_dof);
+ Vector<double> &d_p = newton_update.block(p_dof);
+ Vector<double> &d_J = newton_update.block(J_dof);
const auto K_uu =
linear_operator(tangent_matrix.block(u_dof, u_dof));
const auto K_up =
static const SymmetricTensor<4, dim> dev_P;
};
template <int dim>
- const SymmetricTensor<2, dim>
- StandardTensors<dim>::I = unit_symmetric_tensor<dim>();
+ const SymmetricTensor<2, dim> StandardTensors<dim>::I =
+ unit_symmetric_tensor<dim>();
template <int dim>
const SymmetricTensor<4, dim> StandardTensors<dim>::IxI = outer_product(I, I);
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::II = identity_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::II =
+ identity_tensor<dim>();
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::dev_P = deviator_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::dev_P =
+ deviator_tensor<dim>();
class Time
{
public:
template <typename NumberType>
SymmetricTensor<2, dim, NumberType>
get_tau(const Tensor<2, dim, NumberType> &F,
- const NumberType & p_tilde) const
+ const NumberType &p_tilde) const
{
return get_tau_iso(F) + get_tau_vol(F, p_tilde);
}
template <typename NumberType>
SymmetricTensor<2, dim, NumberType>
get_tau_vol(const Tensor<2, dim, NumberType> &F,
- const NumberType & p_tilde) const
+ const NumberType &p_tilde) const
{
const NumberType det_F = determinant(F);
// return p_tilde * det_F * StandardTensors<dim>::I;
template <typename NumberType>
SymmetricTensor<2, dim, NumberType>
get_tau(const Tensor<2, dim, NumberType> &F,
- const NumberType & p_tilde) const
+ const NumberType &p_tilde) const
{
return material->get_tau(F, p_tilde);
}
void
assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_ASM & scratch,
- PerTaskData_ASM & data) const;
+ ScratchData_ASM &scratch,
+ PerTaskData_ASM &data) const;
void
copy_local_to_global_system(const PerTaskData_ASM &data);
void
void
assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void
copy_local_to_global_sc(const PerTaskData_SC &data);
void
get_error_residual(Errors &error_residual);
void
get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double>
get_error_dilation(const BlockVector<double> &solution_total) const;
void
const BlockVector<double> &solution_total;
FEValues<dim> fe_values_ref;
FEFaceValues<dim> fe_face_values_ref;
- ScratchData_ASM(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_ASM(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
void
Solid<dim, number_t, ad_type_code>::get_error_update(
const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler_ref.n_dofs(); ++i)
void
Solid<dim, number_t, ad_type_code>::assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_ASM & scratch,
- PerTaskData_ASM & data) const
+ ScratchData_ASM &scratch,
+ PerTaskData_ASM &data) const
{
data.reset();
scratch.reset();
void
Solid<dim, number_t, ad_type_code>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
const Vector<double> &f_u = system_rhs.block(u_dof);
const Vector<double> &f_p = system_rhs.block(p_dof);
const Vector<double> &f_J = system_rhs.block(J_dof);
- Vector<double> & d_u = newton_update.block(u_dof);
- Vector<double> & d_p = newton_update.block(p_dof);
- Vector<double> & d_J = newton_update.block(J_dof);
+ Vector<double> &d_u = newton_update.block(u_dof);
+ Vector<double> &d_p = newton_update.block(p_dof);
+ Vector<double> &d_J = newton_update.block(J_dof);
const auto K_uu =
linear_operator(tangent_matrix.block(u_dof, u_dof));
const auto K_up =
SymmetricTensor<2, dim, NumberType> C_inv;
for (unsigned int d = 0; d < dim; ++d)
{
- const NumberType & lambda_squared = eig_C[d].first;
+ const NumberType &lambda_squared = eig_C[d].first;
const Tensor<1, dim, NumberType> &N = eig_C[d].second;
C_inv +=
NumberType(1.0 / lambda_squared) * symmetrize(outer_product(N, N));
const unsigned int n = 10;
std::size_t tape_stats[STAT_SIZE];
- double * xp = new double[n];
+ double *xp = new double[n];
double yp = 0.0;
adouble *x = new adouble[n];
adouble y = 1.0;
const unsigned int n = 10; // Independents
std::size_t tape_stats[STAT_SIZE];
- double * xp = new double[n];
- double * yp = new double[m];
+ double *xp = new double[n];
+ double *yp = new double[m];
adouble *x = new adouble[n];
adouble *y = new adouble[m];
static const SymmetricTensor<4, dim> dev_P;
};
template <int dim>
- const SymmetricTensor<2, dim>
- StandardTensors<dim>::I = unit_symmetric_tensor<dim>();
+ const SymmetricTensor<2, dim> StandardTensors<dim>::I =
+ unit_symmetric_tensor<dim>();
template <int dim>
const SymmetricTensor<4, dim> StandardTensors<dim>::IxI = outer_product(I, I);
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::II = identity_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::II =
+ identity_tensor<dim>();
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::dev_P = deviator_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::dev_P =
+ deviator_tensor<dim>();
class Time
{
public:
void
assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const;
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const;
void
copy_local_to_global_K(const PerTaskData_K &data);
void
void
assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const;
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const;
void
copy_local_to_global_rhs(const PerTaskData_RHS &data);
void
void
assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void
copy_local_to_global_sc(const PerTaskData_SC &data);
void
void
update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
- PerTaskData_UQPH & data);
+ ScratchData_UQPH &scratch,
+ PerTaskData_UQPH &data);
void
copy_local_to_global_UQPH(const PerTaskData_UQPH & /*data*/)
{}
get_error_residual(Errors &error_residual);
void
get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double>
get_error_dilation() const;
double
std::vector<std::vector<Tensor<2, dim>>> grad_Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_K(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, Nx(qf_cell.size(), std::vector<double>(fe_cell.dofs_per_cell))
std::vector<std::vector<double>> Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_RHS(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, fe_face_values_ref(fe_cell, qf_face, uf_face)
template <int dim>
struct Solid<dim>::ScratchData_UQPH
{
- const BlockVector<double> & solution_total;
+ const BlockVector<double> &solution_total;
std::vector<Tensor<2, dim>> solution_grads_u_total;
std::vector<double> solution_values_p_total;
std::vector<double> solution_values_J_total;
FEValues<dim> fe_values_ref;
- ScratchData_UQPH(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_UQPH(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
void
Solid<dim>::update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
+ ScratchData_UQPH &scratch,
PerTaskData_UQPH & /*data*/)
{
const std::vector<std::shared_ptr<PointHistory<dim>>> lqph =
template <int dim>
void
Solid<dim>::get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler_ref.n_dofs(); ++i)
void
Solid<dim>::assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const
{
data.reset();
scratch.reset();
const SymmetricTensor<4, dim> Jc = lqph[q_point]->get_Jc();
const double d2Psi_vol_dJ2 = lqph[q_point]->get_d2Psi_vol_dJ2();
const double det_F = lqph[q_point]->get_det_F();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const std::vector<Tensor<2, dim>> &grad_Nx = scratch.grad_Nx[q_point];
void
Solid<dim>::assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const
{
data.reset();
scratch.reset();
const double J_tilde = lqph[q_point]->get_J_tilde();
const double p_tilde = lqph[q_point]->get_p_tilde();
const double dPsi_vol_dJ = lqph[q_point]->get_dPsi_vol_dJ();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const double JxW = scratch.fe_values_ref.JxW(q_point);
void
Solid<dim>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
const Vector<double> &f_u = system_rhs.block(u_dof);
const Vector<double> &f_p = system_rhs.block(p_dof);
const Vector<double> &f_J = system_rhs.block(J_dof);
- Vector<double> & d_u = newton_update.block(u_dof);
- Vector<double> & d_p = newton_update.block(p_dof);
- Vector<double> & d_J = newton_update.block(J_dof);
+ Vector<double> &d_u = newton_update.block(u_dof);
+ Vector<double> &d_p = newton_update.block(p_dof);
+ Vector<double> &d_J = newton_update.block(J_dof);
const auto K_uu =
linear_operator(tangent_matrix.block(u_dof, u_dof));
const auto K_up =
int i1 = data.entry<int>(" i 7");
const int i2 = data.entry<const int>(" i 7");
double d = data.entry<double>(" d 17.");
- double * p2 = data.entry<double *>(" d* 17.");
+ double *p2 = data.entry<double *>(" d* 17.");
const double *p3 = data.entry<const double *>("cd* 17.");
deallog << i1 << std::endl
void
test_projection(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
- std::ostream & out)
+ std::ostream &out)
{
out << fe1.get_name() << " -> " << fe2.get_name() << std::endl;
{
public:
PETScInverse(const dealii::PETScWrappers::MatrixBase &A,
- dealii::SolverControl & cn,
+ dealii::SolverControl &cn,
const MPI_Comm mpi_communicator = PETSC_COMM_SELF)
: solver(cn)
, matrix(A)
{}
void
- vmult(dealii::PETScWrappers::MPI::Vector & dst,
+ vmult(dealii::PETScWrappers::MPI::Vector &dst,
const dealii::PETScWrappers::MPI::Vector &src) const
{
;
private:
mutable dealii::PETScWrappers::SolverGMRES solver;
- const dealii::PETScWrappers::MatrixBase & matrix;
+ const dealii::PETScWrappers::MatrixBase &matrix;
PETScWrappers::PreconditionBlockJacobi preconditioner;
};
{
public:
PETScInverse(const dealii::PETScWrappers::MatrixBase &A,
- dealii::SolverControl & cn,
+ dealii::SolverControl &cn,
const MPI_Comm mpi_communicator = PETSC_COMM_SELF)
: solver(cn)
, matrix(A)
{}
void
- vmult(dealii::PETScWrappers::MPI::Vector & dst,
+ vmult(dealii::PETScWrappers::MPI::Vector &dst,
const dealii::PETScWrappers::MPI::Vector &src) const
{
;
template <int dim, class PolynomialType1, class PolynomialType2>
void
-check_poly(const Point<dim> & x,
+check_poly(const Point<dim> &x,
const PolynomialType1 &p,
const PolynomialType2 &q)
{
// x or y direction
{
PolVector pols[2] = {Pol::generate_complete_basis(3),
- Pol::generate_complete_basis(1)};
+ Pol::generate_complete_basis(1)};
std::vector<PolVector> p(&pols[0], &pols[2]);
AnisotropicPolynomials<2> aniso(p);
print_2d(aniso);
}
{
PolVector pols[2] = {Pol::generate_complete_basis(2),
- Pol::generate_complete_basis(3)};
+ Pol::generate_complete_basis(3)};
std::vector<PolVector> p(&pols[0], &pols[2]);
AnisotropicPolynomials<2> aniso(p);
// in x, y or z direction
{
PolVector pols[3] = {Pol::generate_complete_basis(3),
- Pol::generate_complete_basis(1),
- Pol::generate_complete_basis(1)};
+ Pol::generate_complete_basis(1),
+ Pol::generate_complete_basis(1)};
std::vector<PolVector> p(&pols[0], &pols[3]);
AnisotropicPolynomials<3> aniso(p);
print_3d(aniso);
}
{
PolVector pols[3] = {Pol::generate_complete_basis(1),
- Pol::generate_complete_basis(3),
- Pol::generate_complete_basis(1)};
+ Pol::generate_complete_basis(3),
+ Pol::generate_complete_basis(1)};
std::vector<PolVector> p(&pols[0], &pols[3]);
AnisotropicPolynomials<3> aniso(p);
print_3d(aniso);
}
{
PolVector pols[3] = {Pol::generate_complete_basis(1),
- Pol::generate_complete_basis(2),
- Pol::generate_complete_basis(3)};
+ Pol::generate_complete_basis(2),
+ Pol::generate_complete_basis(3)};
std::vector<PolVector> p(&pols[0], &pols[3]);
AnisotropicPolynomials<3> aniso(p);
print_3d(aniso);
gradient(const Point<dim> &p, const unsigned int component = 0) const;
virtual void
- vector_gradient(const Point<dim> & p,
+ vector_gradient(const Point<dim> &p,
typename std::vector<Tensor<1, dim>> &gradients) const;
};
template <int dim>
void
ExactSinExp<dim>::vector_gradient(
- const Point<dim> & p,
+ const Point<dim> &p,
typename std::vector<Tensor<1, dim>> &gradients) const
{
Assert(gradients.size() == this->n_components,
const auto c = random_point<dim>();
const auto d = random_value();
box = std::make_pair(BoundingBox<dim>({Point<dim>(c - d * ones),
- Point<dim>(c + d * ones)}),
+ Point<dim>(c + d * ones)}),
i++);
}
const auto c = random_point<dim>();
const auto d = random_value();
box = std::make_pair(BoundingBox<dim>({Point<dim>(c - d * ones),
- Point<dim>(c + d * ones)}),
+ Point<dim>(c + d * ones)}),
i++);
}
void
check_qph(Triangulation<dim> &tr,
CellDataStorage<typename Triangulation<dim, dim>::cell_iterator, DATA>
- & manager,
+ &manager,
const Quadrature<dim> &rhs_quadrature,
const MyFunction<dim> &func)
{
fe_values.reinit(dof_cell);
const std::vector<Point<dim>> &q_points =
fe_values.get_quadrature_points();
- const auto & manager_const = manager;
+ const auto &manager_const = manager;
const std::vector<std::shared_ptr<DATA>> qpd = manager.get_data(cell);
const std::vector<std::shared_ptr<const DATA>> qpd_const =
manager_const.get_data(cell);
void
-setup_history(Triangulation<2> & tria,
+setup_history(Triangulation<2> &tria,
CellDataStorage<typename Triangulation<2>::active_cell_iterator,
MaterialBase> &storage)
{
}
void
-read_history(Triangulation<2> & tria,
+read_history(Triangulation<2> &tria,
CellDataStorage<typename Triangulation<2>::active_cell_iterator,
MaterialBase> &storage)
{
template <int dim>
void
check_derivative_order(const std::vector<Tensor<1, dim>> &gradients,
- FunctionDerivative<dim> & df,
- const Quadrature<dim> & quadrature,
+ FunctionDerivative<dim> &df,
+ const Quadrature<dim> &quadrature,
const unsigned int direction,
const double order)
{
template <int dim>
void
check_hessian_order(const std::vector<double> &values,
- FunctionDerivative<dim> & df,
- const Quadrature<dim> & quadrature,
- const Point<dim> & k,
+ FunctionDerivative<dim> &df,
+ const Quadrature<dim> &quadrature,
+ const Point<dim> &k,
const unsigned int direction,
const double order)
{
void
assemble(const std::vector<int>::iterator &it,
- scratch_data & scratch,
- copy_data & data)
+ scratch_data &scratch,
+ copy_data &data)
{
double s = *it;
double value = fp.value(Point<2>(s, 2.5));
template <int dim>
void
print_derivatives_at_point(const Function<dim> &function,
- const Point<dim> & point)
+ const Point<dim> &point)
{
deallog << "point = " << point << std::endl;
deallog << "value = " << function.value(point) << std::endl;
template <int dim>
void
print_value_and_gradient_at_point(const Function<dim> &function,
- const Point<dim> & point)
+ const Point<dim> &point)
{
deallog << "point = " << point << std::endl;
deallog << "value = " << function.value(point) << std::endl;
value(const Point<dim> &points, const unsigned int component) const;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const;
+ std::vector<Vector<double>> &values) const;
private:
const Function<dim> &func;
void
DerivativeTestFunction<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
func.vector_value_list(points, values);
}
template <int dim>
void
DerivativeTestFunction<dim>::vector_value(const Point<dim> &point,
- Vector<double> & value) const
+ Vector<double> &value) const
{
func.vector_value(point, value);
}
template <int dim>
double
-DerivativeTestFunction<dim>::value(const Point<dim> & point,
+DerivativeTestFunction<dim>::value(const Point<dim> &point,
const unsigned int comp) const
{
// std::cerr << '[' << point << '!' << func.value(point, comp) << ']';
void
check_function(const Functions::FlowFunction<dim> &f,
unsigned int sub,
- std::ostream & out)
+ std::ostream &out)
{
DerivativeTestFunction<dim> dtest1(f, 1.e-2);
DerivativeTestFunction<dim> dtest2(f, 2.e-2);
FillTensor<rank, dim>::fill_tensor(value, 0);
ConstantTensorFunction<rank, dim> tensor_function(value);
- TensorFunction<rank, dim> * foo = &tensor_function;
+ TensorFunction<rank, dim> *foo = &tensor_function;
Point<dim> point;
// native version
{
gsl_interp_accel *acc = gsl_interp_accel_alloc();
- gsl_spline * spline = gsl_spline_alloc(gsl_interp_cspline, n_points);
+ gsl_spline *spline = gsl_spline_alloc(gsl_interp_cspline, n_points);
gsl_spline_init(spline, &x[0], &y[0], n_points);
// native:
gsl_interp_accel *acc = gsl_interp_accel_alloc();
- gsl_spline * spline = gsl_spline_alloc(gsl_interp_cspline, n_points);
+ gsl_spline *spline = gsl_spline_alloc(gsl_interp_cspline, n_points);
gsl_spline_init(spline, &x[0], &y[0], n_points);
void
check_function_derivative(const Functions::FlowFunction<dim> &f,
unsigned int sub,
- std::ostream & out)
+ std::ostream &out)
{
DerivativeTestFunction<dim> dtest1(f, 1.e-2);
DerivativeTestFunction<dim> dtest2(f, 2.e-2);
// This function tests parallel write and gets the group by reference
template <template <class...> class Container, typename Number>
void
-write_test(HDF5::Group & root_group,
+write_test(HDF5::Group &root_group,
const std::vector<hsize_t> dataset_dimensions,
MPI_Comm mpi_communicator,
ConditionalOStream pcout)
// This function tests parallel write and gets the group by reference
template <template <class...> class Container, typename Number>
void
-write_test(HDF5::Group & root_group,
+write_test(HDF5::Group &root_group,
const std::vector<hsize_t> dataset_dimensions)
{
AssertDimension(dataset_dimensions.size(), 2);
// This function tests parallel write and gets the group by reference
template <typename Number>
void
-write_test(HDF5::Group & root_group,
+write_test(HDF5::Group &root_group,
MPI_Comm mpi_communicator,
ConditionalOStream pcout)
{
void
check_interpolation(const std::vector<Polynomial<double>> &p,
- const std::vector<Point<1>> & x)
+ const std::vector<Point<1>> &x)
{
for (unsigned int i = 0; i < p.size(); ++i)
{
void
check_interpolation(const std::vector<Polynomial<double>> &p,
- const std::vector<Point<1>> & x)
+ const std::vector<Point<1>> &x)
{
for (unsigned int i = 0; i < p.size(); ++i)
{
{
quadrature_type quadrature(n);
const std::vector<Point<1>> &points = quadrature.get_points();
- const std::vector<double> & weights = quadrature.get_weights();
+ const std::vector<double> &weights = quadrature.get_weights();
for (unsigned int i = 0; i < 32; ++i)
{
QGaussRadauChebyshev<1> quadrature(n, QGaussRadauChebyshev<1>::right);
const std::vector<Point<1>> &points = quadrature.get_points();
- const std::vector<double> & weights = quadrature.get_weights();
+ const std::vector<double> &weights = quadrature.get_weights();
for (unsigned int i = 0; i < 32; ++i)
template <int dim>
void
check_tensor_product(const std::vector<Quadrature<dim>> &quadratures,
- const std::vector<std::string> & quadrature_names)
+ const std::vector<std::string> &quadrature_names)
{
Assert(false, ExcNotImplemented());
}
template <>
void
check_tensor_product(const std::vector<Quadrature<1>> &quadratures,
- const std::vector<std::string> & quadrature_names)
+ const std::vector<std::string> &quadrature_names)
{
for (unsigned int i = 0; i < quadratures.size(); ++i)
{
template <>
void
check_tensor_product(const std::vector<Quadrature<2>> &quadratures,
- const std::vector<std::string> & quadrature_names)
+ const std::vector<std::string> &quadrature_names)
{
for (unsigned int i = 0; i < quadratures.size(); ++i)
{
template <>
void
check_tensor_product(const std::vector<Quadrature<3>> &quadratures,
- const std::vector<std::string> & quadrature_names)
+ const std::vector<std::string> &quadrature_names)
{
for (unsigned int i = 0; i < quadratures.size(); ++i)
{
template <int dim>
void
fill_quadrature_vector(std::vector<Quadrature<dim>> &quadratures,
- std::vector<std::string> & quadrature_names)
+ std::vector<std::string> &quadrature_names)
{
quadratures.push_back(Quadrature<dim>());
quadrature_names.push_back("Quadrature");
void
check_qph(parallel::distributed::Triangulation<dim> &tr,
const CellDataStorage<typename Triangulation<dim, dim>::cell_iterator,
- DATA> & manager,
- const Quadrature<dim> & rhs_quadrature,
- const MyFunction<dim> & func)
+ DATA> &manager,
+ const Quadrature<dim> &rhs_quadrature,
+ const MyFunction<dim> &func)
{
DoFHandler<dim> dof_handler(tr);
FE_Q<dim> dummy_fe(1);
void
check_qph(parallel::distributed::Triangulation<dim> &tr,
const CellDataStorage<typename Triangulation<dim, dim>::cell_iterator,
- DATA> & manager,
- const Quadrature<dim> & rhs_quadrature,
- const MyFunction<dim> & func)
+ DATA> &manager,
+ const Quadrature<dim> &rhs_quadrature,
+ const MyFunction<dim> &func)
{
DoFHandler<dim> dof_handler(tr);
FE_Q<dim> dummy_fe(1);
void
check_qph(parallel::distributed::Triangulation<dim> &tr,
const CellDataStorage<typename Triangulation<dim, dim>::cell_iterator,
- MyDataBase> & manager,
- const Quadrature<dim> & rhs_quadrature,
- const MyFunction<dim> & func)
+ MyDataBase> &manager,
+ const Quadrature<dim> &rhs_quadrature,
+ const MyFunction<dim> &func)
{
DoFHandler<dim> dof_handler(tr);
FE_Q<dim> dummy_fe(1);
void
initialize_data(const Triangulation<2> &tria,
- QuadratureStorage & storage,
+ QuadratureStorage &storage,
const unsigned int n_data_points_per_cell)
{
deallog << "Initializing quadrature cell data" << std::endl;
void
assign_value_to_data(const Triangulation<2> &tria,
- FEValues<2> & fe_values,
- QuadratureStorage & storage,
+ FEValues<2> &fe_values,
+ QuadratureStorage &storage,
const unsigned int n_data_points_per_cell)
{
deallog << "Assigning quadrature cell data" << std::endl;
<< ", delta = " << arg3);
void
-check_data(const Triangulation<2> & tria,
- FEValues<2> & fe_values,
+check_data(const Triangulation<2> &tria,
+ FEValues<2> &fe_values,
const QuadratureStorage &storage,
const unsigned int n_data_points_per_cell)
{
template <int dim>
void
-check(const std::string & name,
+check(const std::string &name,
const unsigned int order,
const Quadrature<dim> &q)
{
{
quadrature = *quadratures[n];
const std::vector<Point<dim>> &points = quadrature.get_points();
- const std::vector<double> & weights = quadrature.get_weights();
+ const std::vector<double> &weights = quadrature.get_weights();
deallog << "Quadrature no." << n;
QProjector<dim>::project_to_all_subfaces(
ReferenceCells::get_hypercube<dim>(), *quadratures[n]));
const std::vector<Point<dim>> &points = quadrature.get_points();
- const std::vector<double> & weights = quadrature.get_weights();
+ const std::vector<double> &weights = quadrature.get_weights();
deallog << "Quadrature no." << n;
{
quadrature = *quadratures[n];
const std::vector<Point<dim>> &points = quadrature.get_points();
- const std::vector<double> & weights = quadrature.get_weights();
+ const std::vector<double> &weights = quadrature.get_weights();
deallog << "Quadrature no." << n;
QProjector<dim>::project_to_all_subfaces(
ReferenceCells::get_hypercube<dim>(), *quadratures[n]));
const std::vector<Point<dim>> &points = quadrature.get_points();
- const std::vector<double> & weights = quadrature.get_weights();
+ const std::vector<double> &weights = quadrature.get_weights();
deallog << "Quadrature no." << n;
}
void
-test(TimeStepping::RungeKutta<Vector<double>> & solver,
+test(TimeStepping::RungeKutta<Vector<double>> &solver,
std::function<Vector<double>(const double, const Vector<double> &)> f,
std::function<Vector<double>(const double,
const double,
void
test_convergence(
- TimeStepping::RungeKutta<Vector<double>> & solver,
+ TimeStepping::RungeKutta<Vector<double>> &solver,
std::function<Vector<double>(const double, const Vector<double> &)> f,
std::function<Vector<double>(const double,
const double,
}
void
-test(TimeStepping::EmbeddedExplicitRungeKutta<Vector<double>> & solver,
+test(TimeStepping::EmbeddedExplicitRungeKutta<Vector<double>> &solver,
std::function<Vector<double>(const double, const Vector<double> &)> f,
std::function<double(const double)> my)
{
// capture cerr for testing purposes
std::stringstream captured_cerr;
- std::streambuf * old_cerr = std::cerr.rdbuf(captured_cerr.rdbuf());
+ std::streambuf *old_cerr = std::cerr.rdbuf(captured_cerr.rdbuf());
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv);
// Test printing from TimerOutput
Subscriptor subscriptor;
std::atomic<bool> dummy_a;
- const char * foo_a = "a";
- const char * foo_b = "b";
+ const char *foo_a = "a";
+ const char *foo_b = "b";
subscriptor.subscribe(&dummy_a, foo_a);
subscriptor.unsubscribe(&dummy_a, foo_b);
std::atomic<bool> dummy_b;
Subscriptor subscriptor;
std::atomic<bool> dummy_a;
- const char * foo = "a";
+ const char *foo = "a";
const std::string foo_string = "a";
subscriptor.subscribe(&dummy_a, foo);
subscriptor.unsubscribe(&dummy_a, foo_string.c_str());
template <int dim>
inline void
VectorBoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
Assert(values.size() == 2, ExcDimensionMismatch(values.size(), 2));
template <int dim, class InVector, class OutVector>
void
transfer(const DoFHandler<dim> &source_dof,
- const InVector & source_vector,
+ const InVector &source_vector,
const DoFHandler<dim> &target_dof,
- OutVector & target_vector);
+ OutVector &target_vector);
} // namespace DoFToolsEx
/**
template <int dim, class InVector, class OutVector>
void
DoFToolsEx::transfer(const DoFHandler<dim> &source_dof,
- const InVector & source_vector,
+ const InVector &source_vector,
const DoFHandler<dim> &target_dof,
- OutVector & target_vector)
+ OutVector &target_vector)
{
// any sanity tests? Trias derived from same coarse grid?
void
test(const unsigned int chunk_size,
- Vector<double> & v,
- Vector<double> & w,
- Vector<double> & x)
+ Vector<double> &v,
+ Vector<double> &w,
+ Vector<double> &x)
{
// set some entries in the
// matrix. actually, set them all
typename VectorType,
class PRECONDITION>
void
-check_solve(SolverType & solver,
+check_solve(SolverType &solver,
const SolverControl &solver_control,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
- const PRECONDITION & P)
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
+ const PRECONDITION &P)
{
deallog << "Solver type: " << typeid(solver).name() << std::endl;
typename VectorType,
class PRECONDITION>
void
-check_solve(SolverType & solver,
+check_solve(SolverType &solver,
const SolverControl &solver_control,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
- const PRECONDITION & P)
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
+ const PRECONDITION &P)
{
deallog << "Solver type: " << typeid(solver).name() << std::endl;
void
check(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
- const std::string & name)
+ const std::string &name)
{
deallog << "Checking " << name << " in " << dim << "d:" << std::endl;
void
check(const FiniteElement<dim, spacedim> &fe1,
const FiniteElement<dim, spacedim> &fe2,
- const std::string & name)
+ const std::string &name)
{
deallog << "Checking " << name << " in " << dim << "d and spacedim "
<< spacedim << std::endl;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
const unsigned int n_points = 5;
const Point<2> points[n_points] = {Point<2>(0.0, 0.0),
- Point<2>(1.0, 1.0),
- Point<2>(2.0, 2.0),
- Point<2>(0.0, 2.0),
- Point<2>(2.0, 0.0)};
+ Point<2>(1.0, 1.0),
+ Point<2>(2.0, 2.0),
+ Point<2>(0.0, 2.0),
+ Point<2>(2.0, 0.0)};
std::vector<Point<2>> vertices(n_points);
vertices.assign(points, points + n_points);
template <int dim>
void
get_point_value(const DoFHandler<dim> &dof_handler,
- const Point<dim> & point,
- const Vector<double> & solution,
- Vector<double> & value)
+ const Point<dim> &point,
+ const Vector<double> &solution,
+ Vector<double> &value)
{
VectorTools::point_value(dof_handler, solution, point, value);
}
void
check_periodicity(const DoFHandler<2> &dof_handler,
- Vector<double> & solution,
+ Vector<double> &solution,
const unsigned int cycle)
{
unsigned int n_points = 2;
template <int dim>
void
get_point_value(const DoFHandler<dim> &dof_handler,
- const Point<dim> & point,
- const Vector<double> & solution,
- Vector<double> & value)
+ const Point<dim> &point,
+ const Vector<double> &solution,
+ Vector<double> &value)
{
VectorTools::point_value(dof_handler, solution, point, value);
}
void
check_periodicity(const DoFHandler<3> &dof_handler,
- Vector<double> & solution,
+ Vector<double> &solution,
const unsigned int cycle)
{
unsigned int n_points = 2;
}
virtual void
- vector_gradient(const Point<dim> & p,
+ vector_gradient(const Point<dim> &p,
std::vector<Tensor<1, dim>> &gradients) const
{
gradients[0] = gradient(p, 0);
}
virtual void
- vector_gradient(const Point<dim> & p,
+ vector_gradient(const Point<dim> &p,
std::vector<Tensor<1, dim>> &gradients) const
{
gradients(0) = gradient(p, 0);
}
virtual void
- vector_gradient(const Point<dim> & p,
+ vector_gradient(const Point<dim> &p,
std::vector<Tensor<1, dim>> &gradients) const
{
gradients[0] = gradient(p, 0);
}
virtual void
- vector_gradient(const Point<dim> & p,
+ vector_gradient(const Point<dim> &p,
std::vector<Tensor<1, dim>> &gradients) const
{
gradients(0) = gradient(p, 0);
}
virtual void
- vector_gradient(const Point<dim> & p,
+ vector_gradient(const Point<dim> &p,
std::vector<Tensor<1, dim>> &gradients) const
{
gradients[0] = gradient(p, 0);
}
virtual void
- vector_gradient(const Point<dim> & p,
+ vector_gradient(const Point<dim> &p,
std::vector<Tensor<1, dim>> &gradients) const
{
gradients(0) = gradient(p, 0);
}
virtual void
- vector_gradient(const Point<dim> & p,
+ vector_gradient(const Point<dim> &p,
std::vector<Tensor<1, dim>> &gradients) const
{
gradients[0] = gradient(p, 0);
}
virtual void
- vector_gradient(const Point<dim> & p,
+ vector_gradient(const Point<dim> &p,
std::vector<Tensor<1, dim>> &gradients) const
{
gradients(0) = gradient(p, 0);
}
virtual void
- vector_value(const Point<dim> & p,
+ vector_value(const Point<dim> &p,
Vector<VectorType::value_type> &values) const
{
values(0) = value(p, 0);
p[2][d] = 1. / 3.;
}
Vector<VectorType::value_type> value(1);
- const auto & mapping = get_default_linear_mapping(tria);
+ const auto &mapping = get_default_linear_mapping(tria);
for (unsigned int i = 0; i < 3; ++i)
{
{
create_two_cubes(Triangulation<3> &coarse_grid)
{
const Point<3> points[6] = {Point<3>(0, 0, 0),
- Point<3>(1, 0, 0),
- Point<3>(1, 1, 0),
- Point<3>(0, 1, 0),
- Point<3>(2, 0, 0),
- Point<3>(2, 1, 0)};
+ Point<3>(1, 0, 0),
+ Point<3>(1, 1, 0),
+ Point<3>(0, 1, 0),
+ Point<3>(2, 0, 0),
+ Point<3>(2, 1, 0)};
std::vector<Point<3>> vertices;
for (unsigned int i = 0; i < 6; ++i)
vertices.push_back(points[i]);
public:
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
public:
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
{}
void
value_list(const std::vector<Point<dim>> &points,
- std::vector<Point<dim>> & values) const;
+ std::vector<Point<dim>> &values) const;
};
template <int dim>
void
RHS<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
template <int dim>
void
Beta<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<Point<dim>> & values) const
+ std::vector<Point<dim>> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
for (unsigned int i = 0; i < points.size(); ++i)
{
const Point<dim> &p = points[i];
- Point<dim> & beta = values[i];
+ Point<dim> &beta = values[i];
beta(0) = -p(1);
beta(1) = p(0);
template <int dim>
void
BoundaryValues<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
void
assemble_cell_term(const FEValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const;
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const;
void
assemble_boundary_term(const FEFaceValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const;
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const;
void
assemble_face_term1(const FEFaceValuesBase<dim> &fe_v,
const FEFaceValuesBase<dim> &fe_v_neighbor,
- FullMatrix<double> & ui_vi_matrix,
- FullMatrix<double> & ue_vi_matrix) const;
+ FullMatrix<double> &ui_vi_matrix,
+ FullMatrix<double> &ue_vi_matrix) const;
void
assemble_face_term2(const FEFaceValuesBase<dim> &fe_v,
const FEFaceValuesBase<dim> &fe_v_neighbor,
- FullMatrix<double> & ui_vi_matrix,
- FullMatrix<double> & ue_vi_matrix,
- FullMatrix<double> & ui_ve_matrix,
- FullMatrix<double> & ue_ve_matrix) const;
+ FullMatrix<double> &ui_vi_matrix,
+ FullMatrix<double> &ue_vi_matrix,
+ FullMatrix<double> &ui_ve_matrix,
+ FullMatrix<double> &ue_ve_matrix) const;
private:
const Beta<dim> beta_function;
template <int dim>
void
DGTransportEquation<dim>::assemble_cell_term(const FEValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
+ FullMatrix<double> &ui_vi_matrix,
Vector<double> &cell_vector) const
{
const std::vector<double> &JxW = fe_v.get_JxW_values();
void
DGTransportEquation<dim>::assemble_boundary_term(
const FEFaceValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const
{
- const std::vector<double> & JxW = fe_v.get_JxW_values();
+ const std::vector<double> &JxW = fe_v.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_v.get_normal_vectors();
std::vector<Point<dim>> beta(fe_v.n_quadrature_points);
DGTransportEquation<dim>::assemble_face_term1(
const FEFaceValuesBase<dim> &fe_v,
const FEFaceValuesBase<dim> &fe_v_neighbor,
- FullMatrix<double> & ui_vi_matrix,
- FullMatrix<double> & ue_vi_matrix) const
+ FullMatrix<double> &ui_vi_matrix,
+ FullMatrix<double> &ue_vi_matrix) const
{
- const std::vector<double> & JxW = fe_v.get_JxW_values();
+ const std::vector<double> &JxW = fe_v.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_v.get_normal_vectors();
std::vector<Point<dim>> beta(fe_v.n_quadrature_points);
DGTransportEquation<dim>::assemble_face_term2(
const FEFaceValuesBase<dim> &fe_v,
const FEFaceValuesBase<dim> &fe_v_neighbor,
- FullMatrix<double> & ui_vi_matrix,
- FullMatrix<double> & ue_vi_matrix,
- FullMatrix<double> & ui_ve_matrix,
- FullMatrix<double> & ue_ve_matrix) const
+ FullMatrix<double> &ui_vi_matrix,
+ FullMatrix<double> &ue_vi_matrix,
+ FullMatrix<double> &ui_ve_matrix,
+ FullMatrix<double> &ue_ve_matrix) const
{
- const std::vector<double> & JxW = fe_v.get_JxW_values();
+ const std::vector<double> &JxW = fe_v.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_v.get_normal_vectors();
std::vector<Point<dim>> beta(fe_v.n_quadrature_points);
virtual void
operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const = 0;
+ const Vector<double> &solution) const = 0;
protected:
unsigned int refinement_cycle;
{
public:
PointValueEvaluation(const Point<dim> &evaluation_point,
- TableHandler & results_table);
+ TableHandler &results_table);
virtual void
operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const;
+ const Vector<double> &solution) const;
DeclException1(ExcEvaluationPointNotFound,
Point<dim>,
private:
const Point<dim> evaluation_point;
- TableHandler & results_table;
+ TableHandler &results_table;
};
template <int dim>
PointValueEvaluation<dim>::PointValueEvaluation(
const Point<dim> &evaluation_point,
- TableHandler & results_table)
+ TableHandler &results_table)
: evaluation_point(evaluation_point)
, results_table(results_table)
{}
template <int dim>
void
PointValueEvaluation<dim>::operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ const Vector<double> &solution) const
{
double point_value = 1e20;
class SolutionOutput : public EvaluationBase<dim>
{
public:
- SolutionOutput(const std::string & output_name_base,
+ SolutionOutput(const std::string &output_name_base,
const DataOutBase::OutputFormat output_format);
virtual void
operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const;
+ const Vector<double> &solution) const;
private:
const std::string output_name_base;
template <int dim>
SolutionOutput<dim>::SolutionOutput(
- const std::string & output_name_base,
+ const std::string &output_name_base,
const DataOutBase::OutputFormat output_format)
: output_name_base(output_name_base)
, output_format(output_format)
class Solver : public virtual Base<dim>
{
public:
- Solver(Triangulation<dim> & triangulation,
+ Solver(Triangulation<dim> &triangulation,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & boundary_values);
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &boundary_values);
virtual ~Solver();
virtual void
void
assemble_matrix(
- LinearSystem & linear_system,
+ LinearSystem &linear_system,
const typename DoFHandler<dim>::active_cell_iterator &begin_cell,
const typename DoFHandler<dim>::active_cell_iterator &end_cell,
- Threads::Mutex & mutex) const;
+ Threads::Mutex &mutex) const;
};
template <int dim>
- Solver<dim>::Solver(Triangulation<dim> & triangulation,
+ Solver<dim>::Solver(Triangulation<dim> &triangulation,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & boundary_values)
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &boundary_values)
: Base<dim>(triangulation)
, fe(&fe)
, quadrature(&quadrature)
template <int dim>
void
Solver<dim>::assemble_matrix(
- LinearSystem & linear_system,
+ LinearSystem &linear_system,
const typename DoFHandler<dim>::active_cell_iterator &begin_cell,
const typename DoFHandler<dim>::active_cell_iterator &end_cell,
- Threads::Mutex & mutex) const
+ Threads::Mutex &mutex) const
{
FEValues<dim> fe_values(*fe,
*quadrature,
class PrimalSolver : public Solver<dim>
{
public:
- PrimalSolver(Triangulation<dim> & triangulation,
+ PrimalSolver(Triangulation<dim> &triangulation,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
protected:
const SmartPointer<const Function<dim>> rhs_function;
template <int dim>
- PrimalSolver<dim>::PrimalSolver(Triangulation<dim> & triangulation,
+ PrimalSolver<dim>::PrimalSolver(Triangulation<dim> &triangulation,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values)
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values)
: Base<dim>(triangulation)
, Solver<dim>(triangulation, fe, quadrature, boundary_values)
, rhs_function(&rhs_function)
class RefinementGlobal : public PrimalSolver<dim>
{
public:
- RefinementGlobal(Triangulation<dim> & coarse_grid,
+ RefinementGlobal(Triangulation<dim> &coarse_grid,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void
refine_grid();
template <int dim>
- RefinementGlobal<dim>::RefinementGlobal(Triangulation<dim> & coarse_grid,
+ RefinementGlobal<dim>::RefinementGlobal(Triangulation<dim> &coarse_grid,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
+ const Quadrature<dim> &quadrature,
const Function<dim> &rhs_function,
const Function<dim> &boundary_values)
: Base<dim>(coarse_grid)
class RefinementKelly : public PrimalSolver<dim>
{
public:
- RefinementKelly(Triangulation<dim> & coarse_grid,
+ RefinementKelly(Triangulation<dim> &coarse_grid,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void
refine_grid();
template <int dim>
- RefinementKelly<dim>::RefinementKelly(Triangulation<dim> & coarse_grid,
+ RefinementKelly<dim>::RefinementKelly(Triangulation<dim> &coarse_grid,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & rhs_function,
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &rhs_function,
const Function<dim> &boundary_values)
: Base<dim>(coarse_grid)
, PrimalSolver<dim>(coarse_grid,
template <int dim>
void
run_simulation(
- LaplaceSolver::Base<dim> & solver,
+ LaplaceSolver::Base<dim> &solver,
const std::list<Evaluation::EvaluationBase<dim> *> &postprocessor_list)
{
deallog << "Refinement cycle: ";
virtual void
operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const = 0;
+ const Vector<double> &solution) const = 0;
protected:
unsigned int refinement_cycle;
virtual void
operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const;
+ const Vector<double> &solution) const;
DeclException1(ExcEvaluationPointNotFound,
Point<dim>,
template <int dim>
void
PointValueEvaluation<dim>::operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ const Vector<double> &solution) const
{
double point_value = 1e20;
virtual void
operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const;
+ const Vector<double> &solution) const;
DeclException1(ExcEvaluationPointNotFound,
Point<dim>,
void
PointXDerivativeEvaluation<dim>::operator()(
const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ const Vector<double> &solution) const
{
double point_derivative = 0;
virtual void
operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const;
+ const Vector<double> &solution) const;
private:
const std::string output_name_base;
class Solver : public virtual Base<dim>
{
public:
- Solver(Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ Solver(Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & boundary_values);
+ const Function<dim> &boundary_values);
virtual ~Solver();
virtual void
void
assemble_matrix(
- LinearSystem & linear_system,
+ LinearSystem &linear_system,
const typename DoFHandler<dim>::active_cell_iterator &begin_cell,
const typename DoFHandler<dim>::active_cell_iterator &end_cell,
- Threads::Mutex & mutex) const;
+ Threads::Mutex &mutex) const;
};
template <int dim>
- Solver<dim>::Solver(Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ Solver<dim>::Solver(Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & boundary_values)
+ const Function<dim> &boundary_values)
: Base<dim>(triangulation)
, fe(&fe)
, quadrature(&quadrature)
template <int dim>
void
Solver<dim>::assemble_matrix(
- LinearSystem & linear_system,
+ LinearSystem &linear_system,
const typename DoFHandler<dim>::active_cell_iterator &begin_cell,
const typename DoFHandler<dim>::active_cell_iterator &end_cell,
- Threads::Mutex & mutex) const
+ Threads::Mutex &mutex) const
{
FEValues<dim> fe_values(*fe,
*quadrature,
class PrimalSolver : public Solver<dim>
{
public:
- PrimalSolver(Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ PrimalSolver(Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void
solve_problem();
template <int dim>
- PrimalSolver<dim>::PrimalSolver(Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ PrimalSolver<dim>::PrimalSolver(Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values)
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values)
: Base<dim>(triangulation)
, Solver<dim>(triangulation,
fe,
class RefinementGlobal : public PrimalSolver<dim>
{
public:
- RefinementGlobal(Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ RefinementGlobal(Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void
refine_grid();
template <int dim>
RefinementGlobal<dim>::RefinementGlobal(
- Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values)
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values)
: Base<dim>(coarse_grid)
, PrimalSolver<dim>(coarse_grid,
fe,
class RefinementKelly : public PrimalSolver<dim>
{
public:
- RefinementKelly(Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ RefinementKelly(Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void
refine_grid();
template <int dim>
RefinementKelly<dim>::RefinementKelly(
- Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values)
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values)
: Base<dim>(coarse_grid)
, PrimalSolver<dim>(coarse_grid,
fe,
class RefinementWeightedKelly : public PrimalSolver<dim>
{
public:
- RefinementWeightedKelly(Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ RefinementWeightedKelly(Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values,
- const Function<dim> & weighting_function);
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values,
+ const Function<dim> &weighting_function);
virtual void
refine_grid();
template <int dim>
RefinementWeightedKelly<dim>::RefinementWeightedKelly(
- Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values,
- const Function<dim> & weighting_function)
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values,
+ const Function<dim> &weighting_function)
: Base<dim>(coarse_grid)
, PrimalSolver<dim>(coarse_grid,
fe,
public:
virtual void
assemble_rhs(const DoFHandler<dim> &dof_handler,
- Vector<double> & rhs) const = 0;
+ Vector<double> &rhs) const = 0;
};
template <int dim>
void
PointValueEvaluation<dim>::assemble_rhs(const DoFHandler<dim> &dof_handler,
- Vector<double> & rhs) const
+ Vector<double> &rhs) const
{
rhs.reinit(dof_handler.n_dofs());
void
PointXDerivativeEvaluation<dim>::assemble_rhs(
const DoFHandler<dim> &dof_handler,
- Vector<double> & rhs) const
+ Vector<double> &rhs) const
{
rhs.reinit(dof_handler.n_dofs());
class DualSolver : public Solver<dim>
{
public:
- DualSolver(Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
- const Quadrature<dim - 1> & face_quadrature,
+ DualSolver(Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
+ const Quadrature<dim - 1> &face_quadrature,
const DualFunctional::DualFunctionalBase<dim> &dual_functional);
virtual void
template <int dim>
DualSolver<dim>::DualSolver(
- Triangulation<dim> & triangulation,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
- const Quadrature<dim - 1> & face_quadrature,
+ Triangulation<dim> &triangulation,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
+ const Quadrature<dim - 1> &face_quadrature,
const DualFunctional::DualFunctionalBase<dim> &dual_functional)
: Base<dim>(triangulation)
, Solver<dim>(triangulation,
{
public:
WeightedResidual(
- Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & primal_fe,
- const FiniteElement<dim> & dual_fe,
- const Quadrature<dim> & quadrature,
- const Quadrature<dim - 1> & face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values,
+ Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &primal_fe,
+ const FiniteElement<dim> &dual_fe,
+ const Quadrature<dim> &quadrature,
+ const Quadrature<dim - 1> &face_quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values,
const DualFunctional::DualFunctionalBase<dim> &dual_functional);
virtual void
std::vector<double> dual_weights;
typename std::vector<Tensor<2, dim>> cell_grad_grads;
CellData(const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & right_hand_side);
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &right_hand_side);
};
struct FaceData
std::vector<double> dual_weights;
typename std::vector<Tensor<1, dim>> cell_grads;
typename std::vector<Tensor<1, dim>> neighbor_grads;
- FaceData(const FiniteElement<dim> & fe,
+ FaceData(const FiniteElement<dim> &fe,
const Quadrature<dim - 1> &face_quadrature);
};
const Vector<double> &dual_weights,
const unsigned int n_threads,
const unsigned int this_thread,
- Vector<float> & error_indicators,
- FaceIntegrals & face_integrals) const;
+ Vector<float> &error_indicators,
+ FaceIntegrals &face_integrals) const;
void
integrate_over_cell(const active_cell_iterator &cell,
const unsigned int cell_index,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights,
- CellData & cell_data,
- Vector<float> & error_indicators) const;
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights,
+ CellData &cell_data,
+ Vector<float> &error_indicators) const;
void
integrate_over_regular_face(const active_cell_iterator &cell,
const unsigned int face_no,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights,
- FaceData & face_data,
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights,
+ FaceData &face_data,
FaceIntegrals &face_integrals) const;
void
integrate_over_irregular_face(const active_cell_iterator &cell,
const unsigned int face_no,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights,
- FaceData & face_data,
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights,
+ FaceData &face_data,
FaceIntegrals &face_integrals) const;
};
template <int dim>
WeightedResidual<dim>::CellData::CellData(
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quadrature,
- const Function<dim> & right_hand_side)
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &right_hand_side)
: fe_values(fe,
quadrature,
update_values | update_hessians | update_quadrature_points |
template <int dim>
WeightedResidual<dim>::FaceData::FaceData(
- const FiniteElement<dim> & fe,
+ const FiniteElement<dim> &fe,
const Quadrature<dim - 1> &face_quadrature)
: fe_face_values_cell(fe,
face_quadrature,
template <int dim>
WeightedResidual<dim>::WeightedResidual(
- Triangulation<dim> & coarse_grid,
- const FiniteElement<dim> & primal_fe,
- const FiniteElement<dim> & dual_fe,
- const Quadrature<dim> & quadrature,
- const Quadrature<dim - 1> & face_quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & bv,
+ Triangulation<dim> &coarse_grid,
+ const FiniteElement<dim> &primal_fe,
+ const FiniteElement<dim> &dual_fe,
+ const Quadrature<dim> &quadrature,
+ const Quadrature<dim - 1> &face_quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &bv,
const DualFunctional::DualFunctionalBase<dim> &dual_functional)
: Base<dim>(coarse_grid)
, PrimalSolver<dim>(coarse_grid,
WeightedResidual<dim>::output_solution() const
{
const PrimalSolver<dim> &primal_solver = *this;
- const DualSolver<dim> & dual_solver = *this;
+ const DualSolver<dim> &dual_solver = *this;
AffineConstraints<double> primal_hanging_node_constraints;
DoFTools::make_hanging_node_constraints(primal_solver.dof_handler,
WeightedResidual<dim>::estimate_error(Vector<float> &error_indicators) const
{
const PrimalSolver<dim> &primal_solver = *this;
- const DualSolver<dim> & dual_solver = *this;
+ const DualSolver<dim> &dual_solver = *this;
AffineConstraints<double> dual_hanging_node_constraints;
DoFTools::make_hanging_node_constraints(dual_solver.dof_handler,
const Vector<double> &dual_weights,
const unsigned int n_threads,
const unsigned int this_thread,
- Vector<float> & error_indicators,
+ Vector<float> &error_indicators,
FaceIntegrals &face_integrals) const
{
const PrimalSolver<dim> &primal_solver = *this;
- const DualSolver<dim> & dual_solver = *this;
+ const DualSolver<dim> &dual_solver = *this;
CellData cell_data(*dual_solver.fe,
*dual_solver.quadrature,
for (unsigned int t = 0;
(t < this_thread) && (cell != dual_solver.dof_handler.end());
++t, ++cell)
- {}
+ {
+ }
if (cell == dual_solver.dof_handler.end())
for (unsigned int t = 0;
((t < n_threads) && (cell != dual_solver.dof_handler.end()));
++t, ++cell, ++cell_index)
- {}
+ {
+ }
if (cell == dual_solver.dof_handler.end())
break;
WeightedResidual<dim>::integrate_over_cell(
const active_cell_iterator &cell,
const unsigned int cell_index,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights,
- CellData & cell_data,
- Vector<float> & error_indicators) const
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights,
+ CellData &cell_data,
+ Vector<float> &error_indicators) const
{
cell_data.fe_values.reinit(cell);
cell_data.right_hand_side->value_list(
WeightedResidual<dim>::integrate_over_regular_face(
const active_cell_iterator &cell,
const unsigned int face_no,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights,
- FaceData & face_data,
- FaceIntegrals & face_integrals) const
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights,
+ FaceData &face_data,
+ FaceIntegrals &face_integrals) const
{
const unsigned int n_q_points =
face_data.fe_face_values_cell.n_quadrature_points;
WeightedResidual<dim>::integrate_over_irregular_face(
const active_cell_iterator &cell,
const unsigned int face_no,
- const Vector<double> & primal_solution,
- const Vector<double> & dual_weights,
- FaceData & face_data,
- FaceIntegrals & face_integrals) const
+ const Vector<double> &primal_solution,
+ const Vector<double> &dual_weights,
+ FaceData &face_data,
+ FaceIntegrals &face_integrals) const
{
const unsigned int n_q_points =
face_data.fe_face_values_cell.n_quadrature_points;
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().degree;
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().degree;
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
template <int dim>
void
SolutionAndGradient<dim>::vector_value(const Point<dim> &p,
- Vector<double> & v) const
+ Vector<double> &v) const
{
AssertDimension(v.size(), dim + 1);
Solution<dim> solution;
void
assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData & scratch,
- PerTaskData & task_data);
+ ScratchData &scratch,
+ PerTaskData &task_data);
void
copy_local_to_global(const PerTaskData &data);
void
postprocess_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- PostProcessScratchData & scratch,
- unsigned int & empty_data);
+ PostProcessScratchData &scratch,
+ unsigned int &empty_data);
Triangulation<dim> triangulation;
ScratchData(const FiniteElement<dim> &fe,
const FiniteElement<dim> &fe_local,
- const QGauss<dim> & quadrature_formula,
- const QGauss<dim - 1> & face_quadrature_formula,
+ const QGauss<dim> &quadrature_formula,
+ const QGauss<dim - 1> &face_quadrature_formula,
const UpdateFlags local_flags,
const UpdateFlags local_face_flags,
const UpdateFlags flags)
PostProcessScratchData(const FiniteElement<dim> &fe,
const FiniteElement<dim> &fe_local,
- const QGauss<dim> & quadrature_formula,
+ const QGauss<dim> &quadrature_formula,
const UpdateFlags local_flags,
const UpdateFlags flags)
: fe_values_local(fe_local, quadrature_formula, local_flags)
void
HDG<dim>::assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData & scratch,
- PerTaskData & task_data)
+ ScratchData &scratch,
+ PerTaskData &task_data)
{
const auto loc_cell = cell->as_dof_handler_iterator(dof_handler_local);
void
HDG<dim>::postprocess_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- PostProcessScratchData & scratch,
+ PostProcessScratchData &scratch,
unsigned int &)
{
const auto loc_cell = cell->as_dof_handler_iterator(dof_handler_local);
template <int dim>
void
SolutionAndGradient<dim>::vector_value(const Point<dim> &p,
- Vector<double> & v) const
+ Vector<double> &v) const
{
AssertDimension(v.size(), dim + 1);
Solution<dim> solution;
void
assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData & scratch,
- PerTaskData & task_data);
+ ScratchData &scratch,
+ PerTaskData &task_data);
void
copy_local_to_global(const PerTaskData &data);
void
postprocess_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- PostProcessScratchData & scratch,
- unsigned int & empty_data);
+ PostProcessScratchData &scratch,
+ unsigned int &empty_data);
Triangulation<dim> triangulation;
ScratchData(const FiniteElement<dim> &fe,
const FiniteElement<dim> &fe_local,
- const QGauss<dim> & quadrature_formula,
- const QGauss<dim - 1> & face_quadrature_formula,
+ const QGauss<dim> &quadrature_formula,
+ const QGauss<dim - 1> &face_quadrature_formula,
const UpdateFlags local_flags,
const UpdateFlags local_face_flags,
const UpdateFlags flags)
PostProcessScratchData(const FiniteElement<dim> &fe,
const FiniteElement<dim> &fe_local,
- const QGauss<dim> & quadrature_formula,
+ const QGauss<dim> &quadrature_formula,
const UpdateFlags local_flags,
const UpdateFlags flags)
: fe_values_local(fe_local, quadrature_formula, local_flags)
void
HDG<dim>::assemble_system_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData & scratch,
- PerTaskData & task_data)
+ ScratchData &scratch,
+ PerTaskData &task_data)
{
const auto loc_cell = cell->as_dof_handler_iterator(dof_handler_local);
void
HDG<dim>::postprocess_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- PostProcessScratchData & scratch,
+ PostProcessScratchData &scratch,
unsigned int &)
{
const auto loc_cell = cell->as_dof_handler_iterator(dof_handler_local);
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const;
+ std::vector<Vector<double>> &value_list) const;
};
template <int dim>
inline void
RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
Assert(values.size() == dim, ExcDimensionMismatch(values.size(), dim));
Assert(dim >= 2, ExcNotImplemented());
void
RightHandSide<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
Assert(value_list.size() == points.size(),
ExcDimensionMismatch(value_list.size(), points.size()));
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_dgp.h>
-//#include <deal.II/fe/fe_q.h>
+// #include <deal.II/fe/fe_q.h>
#include <deal.II/base/smartpointer.h>
#include <deal.II/fe/fe_tools.h>
void
compute_SD_integral_on_cell(
- std::vector<double> & dst,
+ std::vector<double> &dst,
typename DoFHandler<dim, dim + 1>::active_cell_iterator &cell,
- const Point<dim + 1> & point);
+ const Point<dim + 1> &point);
private:
double
const Tensor<1, 3> &a1,
const Tensor<1, 3> &a2,
const Tensor<1, 3> &n,
- const double & rn_c);
+ const double &rn_c);
double
term_D(const Tensor<1, 3> &r, const Tensor<1, 3> &a1, const Tensor<1, 3> &a2);
template <>
void
LaplaceKernelIntegration<2>::compute_SD_integral_on_cell(
- std::vector<double> & dst,
+ std::vector<double> &dst,
DoFHandler<2, 3>::active_cell_iterator &cell,
- const Point<3> & point)
+ const Point<3> &point)
{
Assert(dst.size() == 2, ExcDimensionMismatch(dst.size(), 2));
fe_values->reinit(cell);
const Tensor<1, 3> &a1,
const Tensor<1, 3> &a2,
const Tensor<1, 3> &n,
- const double & rn_c)
+ const double &rn_c)
{
Tensor<1, 3> ra1 = cross_product_3d(r, a1);
Tensor<1, 3> ra2 = cross_product_3d(r, a2);
dof.distribute_dofs(element);
MappingQ<dim, spacedim> mapping(3);
- Quadrature<dim - 1> & q_face = get_q_face<dim>();
+ Quadrature<dim - 1> &q_face = get_q_face<dim>();
std::map<types::boundary_id, const Function<spacedim> *> neumann_bc;
neumann_bc[0] = &function;
dof.distribute_dofs(element);
MappingQ<dim, spacedim> mapping(3);
- Quadrature<dim - 1> & q_face = get_q_face<dim>();
+ Quadrature<dim - 1> &q_face = get_q_face<dim>();
Vector<double> v(dof.n_dofs());
VectorTools::interpolate(mapping, dof, function, v);
const Triangulation<s_dim, spacedim> &boundary_mesh,
std::map<typename Triangulation<s_dim, spacedim>::cell_iterator,
typename Triangulation<s_dim + 1, spacedim>::face_iterator>
- & surface_to_volume_mapping,
+ &surface_to_volume_mapping,
const int verbosity = 1)
{
typename Triangulation<s_dim, spacedim>::active_cell_iterator
template <int M, int N, int type, bool add, bool dof_to_quad>
DEAL_II_HOST_DEVICE void
evaluate_tensor_product(
- const TeamHandle & team_member,
+ const TeamHandle &team_member,
Kokkos::View<double *, MemorySpace::Default::kokkos_space> shape_values,
Kokkos::View<double *, MemorySpace::Default::kokkos_space> shape_gradients,
Kokkos::View<double *, MemorySpace::Default::kokkos_space> co_shape_gradients,
template <int M, int N, int type, bool add, bool dof_to_quad>
DEAL_II_HOST_DEVICE void
evaluate_tensor_product(
- const TeamHandle & team_member,
+ const TeamHandle &team_member,
Kokkos::View<double *, MemorySpace::Default::kokkos_space> shape_values,
Kokkos::View<double *, MemorySpace::Default::kokkos_space> shape_gradients,
Kokkos::View<double *, MemorySpace::Default::kokkos_space> co_shape_gradients,
LinearAlgebra::CUDAWrappers::Vector<double> solution_dev(size);
const std::array<std::string, 3> solver_names{
- {"Cholesky", "LU_dense", "LU_host"}};
+ {"Cholesky", "LU_dense", "LU_host"}};
for (auto solver_type : solver_names)
{
void
-check_matrix(const SparseMatrix<double> & A,
+check_matrix(const SparseMatrix<double> &A,
CUDAWrappers::SparseMatrix<double> &A_dev)
{
cudaError_t cuda_error_code;
- double * val_dev = nullptr;
- int * column_index_dev = nullptr;
- int * row_ptr_dev = nullptr;
+ double *val_dev = nullptr;
+ int *column_index_dev = nullptr;
+ int *row_ptr_dev = nullptr;
std::tie(val_dev, column_index_dev, row_ptr_dev, std::ignore, std::ignore) =
A_dev.get_cusparse_matrix();
}
void
-check_vector(const Vector<double> & a,
+check_vector(const Vector<double> &a,
const LinearAlgebra::ReadWriteVector<double> &b)
{
unsigned int size = a.size();
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
DataOut<dim> data_out;
data_out.attach_dof_handler(dof_handler);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node_x,
- const Vector<double> & v_cell_x)
+ const Vector<double> &v_node_x,
+ const Vector<double> &v_cell_x)
{
BlockVector<double> v_node, v_cell;
make_block_vector(v_node_x, v_node);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
XDataOut<dim> data_out;
data_out.attach_dof_handler(dof_handler);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
XDataOut<dim> data_out;
data_out.attach_dof_handler(dof_handler);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
std::vector<DataComponentInterpretation::DataComponentInterpretation>
data_component_interpretation(
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
DataOut<dim> data_out;
data_out.add_data_vector(dof_handler, v_node, "node_data");
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
DataOut<dim> data_out;
data_out.attach_triangulation(dof_handler.get_triangulation());
return cell;
},
- [](const Triangulation<dim> & t,
+ [](const Triangulation<dim> &t,
const typename Triangulation<dim>::cell_iterator &old_cell) ->
typename Triangulation<dim>::cell_iterator {
if (old_cell != t.end())
for (unsigned int i = 0; i < dofs_per_cell; ++i)
{
- const auto & this_qp = qp[i];
+ const auto &this_qp = qp[i];
const unsigned int i_group = fe.system_to_base_index(i).first.first;
const unsigned int i_comp = fe.system_to_component_index(i).first;
if (i_group == 0)
for (unsigned int i = 0; i < dofs_per_cell; ++i)
{
- const auto & this_qp = qp[i];
+ const auto &this_qp = qp[i];
const unsigned int i_group = fe.system_to_base_index(i).first.first;
const unsigned int i_comp = fe.system_to_component_index(i).first;
if (i_group == 0)
template <int dim, int spacedim>
void
write_patches(const std::vector<DataOutBase::Patch<dim, spacedim>> &patches,
- std::ostream & out)
+ std::ostream &out)
{
std::vector<std::string> names(2);
names[0] = std::string("first name");
check_cont(unsigned int ncells,
unsigned int nsub,
DataOutBase::DXFlags flags,
- std::ostream & out)
+ std::ostream &out)
{
std::vector<DataOutBase::Patch<dim, dim>> patches;
std::ostream &out = log;
char name[100];
- const char * format = "%d%d%s.dx";
+ const char *format = "%d%d%s.dx";
DataOutBase::DXFlags flags(false, false, false, false);
if (dim == 2 && spacedim == 2)
{
check_cont(unsigned int ncells,
unsigned int nsub,
DataOutBase::EpsFlags flags,
- std::ostream & out)
+ std::ostream &out)
{
std::vector<DataOutBase::Patch<dim, dim>> patches;
#endif
char name[100];
- const char * format = "%d%d%d%s.eps";
+ const char *format = "%d%d%d%s.eps";
DataOutBase::EpsFlags flags;
if (true)
#endif
char name[100];
- const char * format = "%d%d.gnuplot";
+ const char *format = "%d%d.gnuplot";
DataOutBase::GnuplotFlags flags;
for (unsigned int i = 0; i < 5; ++i)
{
#endif
char name[100];
- const char * format = "%d%d.gnuplot";
+ const char *format = "%d%d.gnuplot";
DataOutBase::GnuplotFlags flags;
for (unsigned int i = 0; i < 5; ++i)
{
{
public:
DataOutX(const std::vector<::DataOutBase::Patch<dim, spacedim>> &patches,
- const std::vector<std::string> & names)
+ const std::vector<std::string> &names)
: patches(patches)
, names(names)
{}
private:
const std::vector<::DataOutBase::Patch<dim, spacedim>> &patches;
- const std::vector<std::string> & names;
+ const std::vector<std::string> &names;
};
check_cont(unsigned int ncells,
unsigned int nsub,
DataOutBase::PovrayFlags flags,
- std::ostream & out)
+ std::ostream &out)
{
std::vector<DataOutBase::Patch<dim, dim>> patches;
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell);
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell);
void
ComputeMagnitude<dim>::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
Assert(computed_quantities.size() == inputs.solution_values.size(),
ExcDimensionMismatch(computed_quantities.size(),
void
ComputeMagnitudes<dim>::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
Assert(computed_quantities.size() == inputs.solution_values.size(),
ExcDimensionMismatch(computed_quantities.size(),
virtual void
evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const;
+ std::vector<Vector<double>> &computed_quantities) const;
};
template <int dim>
void
ComplexMagnitude<dim>::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
Assert(computed_quantities.size() == inputs.solution_values.size(),
ExcDimensionMismatch(computed_quantities.size(),
virtual void
evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const;
+ std::vector<Vector<double>> &computed_quantities) const;
};
template <int dim>
void
ComplexPhase<dim>::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
Assert(computed_quantities.size() == inputs.solution_values.size(),
ExcDimensionMismatch(computed_quantities.size(),
void
-laplace_solve(const SparseMatrix<double> & S,
+laplace_solve(const SparseMatrix<double> &S,
const AffineConstraints<double> &constraints,
- Vector<double> & u)
+ Vector<double> &u)
{
const unsigned int n_dofs = S.n();
const auto op = linear_operator(S);
template <int dim>
void
my_check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
DataOutFaces<dim> data_out_faces;
data_out_faces.attach_dof_handler(dof_handler);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
// since we can't forward declare
// check_this in this file (it is forward
template <int dim>
void
my_check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node_x,
- const Vector<double> & v_cell_x)
+ const Vector<double> &v_node_x,
+ const Vector<double> &v_cell_x)
{
BlockVector<double> v_node, v_cell;
make_block_vector(v_node_x, v_node);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
// since we can't forward declare
// check_this in this file (it is forward
template <int dim>
void
my_check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
XDataOut<dim> data_out;
data_out.attach_dof_handler(dof_handler);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
// since we can't forward declare
// check_this in this file (it is forward
template <int dim>
void
my_check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
XDataOut<dim> data_out;
data_out.attach_dof_handler(dof_handler);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
// since we can't forward declare
// check_this in this file (it is forward
template <int dim>
void
my_check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
DataOutFaces<dim> data_out_faces;
data_out_faces.add_data_vector(dof_handler, v_node, "node_data");
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
// since we can't forward declare
// check_this in this file (it is forward
template <int dim>
void
right_hand_side(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & values)
+ std::vector<Tensor<1, dim>> &values)
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
virtual void
evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &input_data,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
AssertDimension(input_data.solution_gradients.size(),
computed_quantities.size());
template <int dim>
void
right_hand_side(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & values)
+ std::vector<Tensor<1, dim>> &values)
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
virtual void
evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &input_data,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
AssertDimension(input_data.solution_gradients.size(),
computed_quantities.size());
template <int dim>
void
my_check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
DataOutRotation<dim> data_out_rotation;
data_out_rotation.attach_dof_handler(dof_handler);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
// since we can't forward declare
// check_this in this file (it is forward
template <int dim>
void
my_check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node_x,
- const Vector<double> & v_cell_x)
+ const Vector<double> &v_node_x,
+ const Vector<double> &v_cell_x)
{
BlockVector<double> v_node, v_cell;
make_block_vector(v_node_x, v_node);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
// since we can't forward declare
// check_this in this file (it is forward
template <int dim>
void
my_check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
XDataOut<dim> data_out;
data_out.attach_dof_handler(dof_handler);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
// since we can't forward declare
// check_this in this file (it is forward
template <int dim>
void
my_check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
XDataOut<dim> data_out;
data_out.attach_dof_handler(dof_handler);
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
// since we can't forward declare
// check_this in this file (it is forward
template <int dim>
void
my_check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
DataOutRotation<dim> data_out_rotation;
data_out_rotation.add_data_vector(dof_handler, v_node, "node_data");
template <int dim>
void
check_this(const DoFHandler<dim> &dof_handler,
- const Vector<double> & v_node,
- const Vector<double> & v_cell)
+ const Vector<double> &v_node,
+ const Vector<double> &v_cell)
{
// since we can't forward declare check_this in this file (it is forward
// declared in data_out_common.h), we also can't make the driver file aware
template <>
void
-check_this<1>(const DoFHandler<1> & dof_handler,
+check_this<1>(const DoFHandler<1> &dof_handler,
const Vector<double> &v_node,
const Vector<double> &v_cell)
{
template <>
void
-check_this<1>(const DoFHandler<1> & dof_handler,
+check_this<1>(const DoFHandler<1> &dof_handler,
const Vector<double> &v_node,
const Vector<double> &v_cell)
{
smoothing_option = dealii::Triangulation<dim>::none);
void
run(std::vector<unsigned int> &n_cell,
- std::set<Location<dim>> & position_list);
+ std::set<Location<dim>> &position_list);
private:
void
template <int dim>
void
TriaTest<dim>::run(std::vector<unsigned int> &n_cell,
- std::set<Location<dim>> & position_list)
+ std::set<Location<dim>> &position_list)
{
n_cell.clear();
position_list.clear();
smoothing_option = dealii::Triangulation<dim>::none);
void
run(std::vector<unsigned int> &n_cell,
- std::set<Location<dim>> & position_list);
+ std::set<Location<dim>> &position_list);
private:
void
template <int dim>
void
TriaTest<dim>::run(std::vector<unsigned int> &n_cell,
- std::set<Location<dim>> & position_list)
+ std::set<Location<dim>> &position_list)
{
n_cell.clear();
position_list.clear();
template <int dim, int spacedim>
void
write_vtk(const parallel::distributed::Triangulation<dim, spacedim> &tria,
- const char * filename)
+ const char *filename)
{
AssertThrow(tria.are_vertices_communicated_to_p4est(),
ExcMessage("To use this function the flag "
void
test_global_refinement_parallel(
void (*test_block_list)(const parallel::distributed::Triangulation<dim> &tr,
- const FiniteElement<dim> & fe))
+ const FiniteElement<dim> &fe))
{
parallel::distributed::Triangulation<dim> trl(
MPI_COMM_WORLD,
template <int dim>
void
test_block_list(const parallel::distributed::Triangulation<dim> &tr,
- const FiniteElement<dim> & fe)
+ const FiniteElement<dim> &fe)
{
deallog << fe.get_name() << std::endl;
void
make_stokes_matrix(const DoFHandler<dim> &dof_handler,
const Quadrature<dim> &quadrature_formula,
- SparseMatrix<double> & system_matrix)
+ SparseMatrix<double> &system_matrix)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
const unsigned int degree = fe.degree;
check_renumbering(DoFHandler<dim> &mgdof, bool discontinuous)
{
const FiniteElement<dim> &element = mgdof.get_fe();
- DoFHandler<dim> & dof = mgdof;
+ DoFHandler<dim> &dof = mgdof;
// Prepare a reordering of
// components for later use
void
print_dofs(const DoFHandler<dim> &dof)
{
- const FiniteElement<dim> & fe = dof.get_fe();
+ const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v(fe.dofs_per_cell);
std::shared_ptr<FEValues<dim>> fevalues;
void
print_dofs(const DoFHandler<dim> &dof, unsigned int level)
{
- const FiniteElement<dim> & fe = dof.get_fe();
+ const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v(fe.dofs_per_cell);
std::shared_ptr<FEValues<dim>> fevalues;
check_renumbering(DoFHandler<dim> &mgdof)
{
const FiniteElement<dim> &element = mgdof.get_fe();
- DoFHandler<dim> & dof = mgdof;
+ DoFHandler<dim> &dof = mgdof;
deallog << element.get_name() << std::endl;
// Prepare a reordering of
void
print_dofs(const DoFHandler<dim> &dof)
{
- const FiniteElement<dim> & fe = dof.get_fe();
+ const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v(fe.dofs_per_cell);
std::shared_ptr<FEValues<dim>> fevalues;
void
print_dofs(const DoFHandler<dim> &dof)
{
- const FiniteElement<dim> & fe = dof.get_fe();
+ const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v(fe.dofs_per_cell);
std::shared_ptr<FEValues<dim>> fevalues;
void
print_dofs(const DoFHandler<dim> &dof)
{
- const FiniteElement<dim> & fe = dof.get_fe();
+ const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v(fe.dofs_per_cell);
std::shared_ptr<FEValues<dim>> fevalues;
void
print_dofs(const DoFHandler<dim> &dof)
{
- const FiniteElement<dim> & fe = dof.get_fe();
+ const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v(fe.dofs_per_cell);
std::shared_ptr<FEValues<dim>> fevalues;
void
print_dofs(const DoFHandler<dim> &dof)
{
- const FiniteElement<dim> & fe = dof.get_fe();
+ const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v(fe.dofs_per_cell);
std::shared_ptr<FEValues<dim>> fevalues;
void
print_dofs(const DoFHandler<dim> &dof)
{
- const FiniteElement<dim> & fe = dof.get_fe();
+ const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v(fe.dofs_per_cell);
std::shared_ptr<FEValues<dim>> fevalues;
void
print_dofs(const DoFHandler<dim> &dof, stream &out)
{
- const FiniteElement<dim> & fe = dof.get_fe();
+ const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v(fe.dofs_per_cell);
std::shared_ptr<FEValues<dim>> fevalues;
{
out << std::setprecision(2);
out << std::fixed;
- const FiniteElement<dim> & fe = dof.get_fe();
+ const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v(fe.dofs_per_cell);
std::shared_ptr<FEValues<dim>> fevalues;
private:
Triangulation<dim> *tria;
- DoFHandler<dim> * dof;
+ DoFHandler<dim> *dof;
CurvedLine<dim> curved_line;
Ball<dim> ball;
};
generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
- Point<3>(+1., -1., -3.),
- Point<3>(-1., +1., -3.),
- Point<3>(+1., +1., -3.),
- Point<3>(-1., -1., -1.),
- Point<3>(+1., -1., -1.),
- Point<3>(-1., +1., -1.),
- Point<3>(+1., +1., -1.),
- Point<3>(-1., -1., +1.),
- Point<3>(+1., -1., +1.),
- Point<3>(-1., +1., +1.),
- Point<3>(+1., +1., +1.),
- Point<3>(-1., -1., +3.),
- Point<3>(+1., -1., +3.),
- Point<3>(-1., +1., +3.),
- Point<3>(+1., +1., +3.)};
+ Point<3>(+1., -1., -3.),
+ Point<3>(-1., +1., -3.),
+ Point<3>(+1., +1., -3.),
+ Point<3>(-1., -1., -1.),
+ Point<3>(+1., -1., -1.),
+ Point<3>(-1., +1., -1.),
+ Point<3>(+1., +1., -1.),
+ Point<3>(-1., -1., +1.),
+ Point<3>(+1., -1., +1.),
+ Point<3>(-1., +1., +1.),
+ Point<3>(+1., +1., +1.),
+ Point<3>(-1., -1., +3.),
+ Point<3>(+1., -1., +3.),
+ Point<3>(-1., +1., +3.),
+ Point<3>(+1., +1., +3.)};
std::vector<Point<3>> vertices(&vertices_1[0], &vertices_1[16]);
std::vector<CellData<3>> cells(2, CellData<3>());
generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
- Point<3>(+1., -1., -3.),
- Point<3>(-1., +1., -3.),
- Point<3>(+1., +1., -3.),
- Point<3>(-1., -1., -1.),
- Point<3>(+1., -1., -1.),
- Point<3>(-1., +1., -1.),
- Point<3>(+1., +1., -1.),
- Point<3>(-1., -1., +1.),
- Point<3>(+1., -1., +1.),
- Point<3>(-1., +1., +1.),
- Point<3>(+1., +1., +1.),
- Point<3>(-1., -1., +3.),
- Point<3>(+1., -1., +3.),
- Point<3>(-1., +1., +3.),
- Point<3>(+1., +1., +3.)};
+ Point<3>(+1., -1., -3.),
+ Point<3>(-1., +1., -3.),
+ Point<3>(+1., +1., -3.),
+ Point<3>(-1., -1., -1.),
+ Point<3>(+1., -1., -1.),
+ Point<3>(-1., +1., -1.),
+ Point<3>(+1., +1., -1.),
+ Point<3>(-1., -1., +1.),
+ Point<3>(+1., -1., +1.),
+ Point<3>(-1., +1., +1.),
+ Point<3>(+1., +1., +1.),
+ Point<3>(-1., -1., +3.),
+ Point<3>(+1., -1., +3.),
+ Point<3>(-1., +1., +3.),
+ Point<3>(+1., +1., +3.)};
std::vector<Point<3>> vertices(&vertices_1[0], &vertices_1[16]);
std::vector<CellData<3>> cells(2, CellData<3>());
template <int dim>
void
write_mesh(const parallel::shared::Triangulation<dim> &tria,
- const char * filename_)
+ const char *filename_)
{
DataOut<dim> data_out;
data_out.attach_triangulation(tria);
template <int dim>
void
write_mesh(const parallel::shared::Triangulation<dim> &tria,
- const char * filename_)
+ const char *filename_)
{
DataOut<dim> data_out;
data_out.attach_triangulation(tria);
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
template <int dim>
void
-create_mass_matrix(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof,
- const Quadrature<dim> & q,
- SparseMatrix<double> & matrix,
- const Function<dim> & rhs_function,
- Vector<double> & rhs_vector,
+create_mass_matrix(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof,
+ const Quadrature<dim> &q,
+ SparseMatrix<double> &matrix,
+ const Function<dim> &rhs_function,
+ Vector<double> &rhs_vector,
const Function<dim> *const coefficient = nullptr)
{
UpdateFlags update_flags =
template <int dim>
void
-create_right_hand_side(const Mapping<dim> & mapping,
+create_right_hand_side(const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler,
const Quadrature<dim> &quadrature,
- const Function<dim> & rhs_function,
- Vector<double> & rhs_vector)
+ const Function<dim> &rhs_function,
+ Vector<double> &rhs_vector)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
Assert(fe.n_components() == rhs_function.n_components, ExcInternalError());
template <int dim>
void
-project(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof,
+project(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
- const Quadrature<dim> & quadrature,
- const Function<dim> & function,
- Vector<double> & vec,
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &function,
+ Vector<double> &vec,
const bool enforce_zero_boundary = false,
- const Quadrature<dim - 1> & = QGauss<dim - 1>(2),
+ const Quadrature<dim - 1> & = QGauss<dim - 1>(2),
const bool project_to_boundary_first = false)
{
Assert(dof.get_fe().n_components() == function.n_components,
else
// no homogeneous boundary values
if (project_to_boundary_first == true)
- // boundary projection required
- {
- /*
- // set up a list of boundary functions for
- // the different boundary parts. We want the
- // @p{function} to hold on all parts of the
- // boundary
- std::map<types::boundary_id, const Function<dim>*> boundary_functions;
- for (types::boundary_id c=0; c<255; ++c)
- boundary_functions[c] = &function;
- project_boundary_values (dof, boundary_functions, q_boundary,
- boundary_values);
- */
- }
+ // boundary projection required
+ {
+ /*
+ // set up a list of boundary functions for
+ // the different boundary parts. We want the
+ // @p{function} to hold on all parts of the
+ // boundary
+ std::map<types::boundary_id, const Function<dim>*> boundary_functions;
+ for (types::boundary_id c=0; c<255; ++c)
+ boundary_functions[c] = &function;
+ project_boundary_values (dof, boundary_functions, q_boundary,
+ boundary_values);
+ */
+ }
// set up mass matrix and right hand side
template <int dim>
void
-create_mass_matrix(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof,
- const Quadrature<dim> & q,
- SparseMatrix<double> & matrix,
- const Function<dim> & rhs_function,
- Vector<double> & rhs_vector,
+create_mass_matrix(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof,
+ const Quadrature<dim> &q,
+ SparseMatrix<double> &matrix,
+ const Function<dim> &rhs_function,
+ Vector<double> &rhs_vector,
const Function<dim> *const coefficient = nullptr)
{
UpdateFlags update_flags =
template <int dim>
void
-create_right_hand_side(const Mapping<dim> & mapping,
+create_right_hand_side(const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler,
const Quadrature<dim> &quadrature,
- const Function<dim> & rhs_function,
- Vector<double> & rhs_vector)
+ const Function<dim> &rhs_function,
+ Vector<double> &rhs_vector)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
Assert(fe.n_components() == rhs_function.n_components, ExcInternalError());
template <int dim>
void
-project(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof,
+project(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
- const Quadrature<dim> & quadrature,
- const Function<dim> & function,
- Vector<double> & vec,
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &function,
+ Vector<double> &vec,
const bool enforce_zero_boundary = false,
- const Quadrature<dim - 1> & = QGauss<dim - 1>(2),
+ const Quadrature<dim - 1> & = QGauss<dim - 1>(2),
const bool project_to_boundary_first = false)
{
Assert(dof.get_fe().n_components() == function.n_components,
template <int dim>
void
TestMap1<dim>::vector_value(const Point<dim> &p,
- Vector<double> & return_value) const
+ Vector<double> &return_value) const
{
Assert(return_value.size() == this->n_components,
ExcDimensionMismatch(return_value.size(), this->n_components));
template <int dim>
void
TestDef1<dim>::vector_value(const Point<dim> &p,
- Vector<double> & return_value) const
+ Vector<double> &return_value) const
{
Assert(return_value.size() == this->n_components,
ExcDimensionMismatch(return_value.size(), this->n_components));
template <int dim>
void
TestDef2<dim>::vector_value(const Point<dim> &p,
- Vector<double> & return_value) const
+ Vector<double> &return_value) const
{
Assert(return_value.size() == this->n_components,
ExcDimensionMismatch(return_value.size(), this->n_components));
template <int dim>
void
TestDef3<dim>::vector_value(const Point<dim> &p,
- Vector<double> & return_value) const
+ Vector<double> &return_value) const
{
Assert(return_value.size() == this->n_components,
ExcDimensionMismatch(return_value.size(), this->n_components));
template <int dim>
void
TestPoly<dim>::vector_value(const Point<dim> &p,
- Vector<double> & return_value) const
+ Vector<double> &return_value) const
{
Assert(return_value.size() == this->n_components,
ExcDimensionMismatch(return_value.size(), this->n_components));
deallog.get_file_stream() << std::fixed;
Triangulation<2> tria_test;
- DoFHandler<2> * dof_handler, *dof_handler_def;
+ DoFHandler<2> *dof_handler, *dof_handler_def;
Point<2> p1(0, 0), p2(1, 1);
GridGenerator::hyper_rectangle(tria_test, p1, p2);
vector_value(const Point<dim> &p, Vector<double> &result) const;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const;
+ std::vector<Vector<double>> &values) const;
private:
static const double bc_constant;
vector_value(const Point<dim> &p, Vector<double> &values) const;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const;
+ std::vector<Vector<double>> &value_list) const;
private:
static const double bc_constant;
// DEFINE EXACT SOLUTION MEMBERS
template <int dim>
double
-ExactSolution<dim>::value(const Point<dim> & p,
+ExactSolution<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(dim >= 2, ExcNotImplemented());
template <int dim>
void
ExactSolution<dim>::vector_value(const Point<dim> &p,
- Vector<double> & result) const
+ Vector<double> &result) const
{
Assert(dim >= 2, ExcNotImplemented());
result(0) = cos(numbers::PI * p(0)) * sin(numbers::PI * p(1)) + bc_constant;
template <int dim>
void
ExactSolution<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
template <int dim>
inline void
RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
Assert(values.size() == dim, ExcDimensionMismatch(values.size(), dim));
Assert(dim >= 2, ExcNotImplemented());
void
RightHandSide<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
Assert(value_list.size() == points.size(),
ExcDimensionMismatch(value_list.size(), points.size()));
template <int dim>
void
TestMap1<dim>::vector_value(const Point<dim> &p,
- Vector<double> & return_value) const
+ Vector<double> &return_value) const
{
Assert(return_value.size() == this->n_components,
ExcDimensionMismatch(return_value.size(), this->n_components));
template <int dim>
void
-create_mass_matrix(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof,
- const Quadrature<dim> & q,
- SparseMatrix<double> & matrix,
- const Function<dim> & rhs_function,
- Vector<double> & rhs_vector,
+create_mass_matrix(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof,
+ const Quadrature<dim> &q,
+ SparseMatrix<double> &matrix,
+ const Function<dim> &rhs_function,
+ Vector<double> &rhs_vector,
const Function<dim> *const coefficient = nullptr)
{
UpdateFlags update_flags =
template <int dim>
void
-create_right_hand_side(const Mapping<dim> & mapping,
+create_right_hand_side(const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler,
const Quadrature<dim> &quadrature,
- const Function<dim> & rhs_function,
- Vector<double> & rhs_vector)
+ const Function<dim> &rhs_function,
+ Vector<double> &rhs_vector)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
Assert(fe.n_components() == rhs_function.n_components, ExcInternalError());
template <int dim>
void
-project(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof,
+project(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
- const Quadrature<dim> & quadrature,
- const Function<dim> & function,
- Vector<double> & vec,
+ const Quadrature<dim> &quadrature,
+ const Function<dim> &function,
+ Vector<double> &vec,
const unsigned int min_convergence_steps,
const bool enforce_zero_boundary = false,
- const Quadrature<dim - 1> & = QGauss<dim - 1>(2),
+ const Quadrature<dim - 1> & = QGauss<dim - 1>(2),
const bool project_to_boundary_first = false)
{
Assert(dof.get_fe().n_components() == function.n_components,
else
// no homogeneous boundary values
if (project_to_boundary_first == true)
- // boundary projection required
- {
- // // set up a list of boundary functions for
- // // the different boundary parts. We want the
- // // @p{function} to hold on all parts of the
- // // boundary
- // std::map<types::boundary_id, const Function<dim>*>
- // boundary_functions; for (unsigned char c=0; c<255; ++c)
- // boundary_functions[c] = &function;
- // project_boundary_values (dof,
- // boundary_functions, q_boundary, boundary_values);
- }
+ // boundary projection required
+ {
+ // // set up a list of boundary functions for
+ // // the different boundary parts. We want the
+ // // @p{function} to hold on all parts of the
+ // // boundary
+ // std::map<types::boundary_id, const Function<dim>*>
+ // boundary_functions; for (unsigned char c=0; c<255; ++c)
+ // boundary_functions[c] = &function;
+ // project_boundary_values (dof,
+ // boundary_functions, q_boundary, boundary_values);
+ }
// set up mass matrix and right hand side
void
-check(const FiniteElement<2> & fe,
+check(const FiniteElement<2> &fe,
const std::array<unsigned int, 3> &min_convergence_steps)
{
Triangulation<2> tria_test;
- DoFHandler<2> * dof_handler;
+ DoFHandler<2> *dof_handler;
deallog << "Dofs/cell " << fe.dofs_per_cell << "Dofs/face "
<< fe.dofs_per_face << std::endl;
template <int dim>
inline void
-plot_derivatives(Mapping<dim> & mapping,
+plot_derivatives(Mapping<dim> &mapping,
FiniteElement<dim> &finel,
- const char * name)
+ const char *name)
{
deallog.push(name);
#include <vector>
#include "../tests.h"
-//#include "../../include/fe_bernstein.h"
+// #include "../../include/fe_bernstein.h"
template <int dim>
inline void
-plot_derivatives(Mapping<dim> & mapping,
+plot_derivatives(Mapping<dim> &mapping,
FiniteElement<dim> &finel,
- const char * name)
+ const char *name)
{
deallog.push(name);
template <int dim>
inline void
-plot_derivatives(Mapping<dim> & mapping,
+plot_derivatives(Mapping<dim> &mapping,
FiniteElement<dim> &finel,
- const char * name)
+ const char *name)
{
deallog.push(name);
void
get_function_jump(const FEInterfaceValues<dim> &fe_interface_values,
- const Vector<double> & dof_vector,
- std::vector<double> & jumps);
+ const Vector<double> &dof_vector,
+ std::vector<double> &jumps);
void
get_normal_jump(const FEInterfaceValues<dim> &fe_interface_values,
- const Vector<double> & dof_vector,
- std::vector<double> & jumps);
+ const Vector<double> &dof_vector,
+ std::vector<double> &jumps);
void
get_tangential_jump(const FEInterfaceValues<dim> &fe_interface_values,
- const Vector<double> & dof_vector,
- std::vector<double> & jumps);
+ const Vector<double> &dof_vector,
+ std::vector<double> &jumps);
SmartPointer<const FiniteElement<dim>> fe_ptr;
Triangulation<dim> triangulation;
void
FEConformityTest<dim>::get_function_jump(
const FEInterfaceValues<dim> &fe_interface_values,
- const Vector<double> & dof_vector,
- std::vector<double> & jumps)
+ const Vector<double> &dof_vector,
+ std::vector<double> &jumps)
{
const unsigned n_q = fe_interface_values.n_quadrature_points;
void
FEConformityTest<dim>::get_normal_jump(
const FEInterfaceValues<dim> &fe_interface_values,
- const Vector<double> & dof_vector,
- std::vector<double> & jumps)
+ const Vector<double> &dof_vector,
+ std::vector<double> &jumps)
{
const unsigned n_q = fe_interface_values.n_quadrature_points;
void
FEConformityTest<2>::get_tangential_jump(
const FEInterfaceValues<2> &fe_interface_values,
- const Vector<double> & dof_vector,
- std::vector<double> & jumps)
+ const Vector<double> &dof_vector,
+ std::vector<double> &jumps)
{
const unsigned n_q = fe_interface_values.n_quadrature_points;
void
FEConformityTest<3>::get_tangential_jump(
const FEInterfaceValues<3> &fe_interface_values,
- const Vector<double> & dof_vector,
- std::vector<double> & jumps)
+ const Vector<double> &dof_vector,
+ std::vector<double> &jumps)
{
const unsigned n_q = fe_interface_values.n_quadrature_points;
#include "../tests.h"
// uncomment when debugging
-//#define DATA_OUT_FE_ENRICHED
+// #define DATA_OUT_FE_ENRICHED
/*
* Predicate function needed by ColorEnriched::internal::color_predicates
fe_enriched,
vec_predicates,
vec_enrichments);
- const hp::FECollection<dim> & fe_collection(
+ const hp::FECollection<dim> &fe_collection(
fe_space.build_fe_collection(dof_handler));
// check if fe_collection is correctly constructed by function
{}
void
- initialize(const Point<dim> & center,
- const double & sigma,
+ initialize(const Point<dim> ¢er,
+ const double &sigma,
const std::string &func_expr);
double
value(const Point<dim> &p, const unsigned int component = 0) const;
gradient(const Point<dim> &p, const unsigned int component = 0) const;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & value_list) const;
+ std::vector<double> &value_list) const;
};
template <int dim>
void
-SigmaFunction<dim>::initialize(const Point<dim> & _center,
- const double & sigma,
+SigmaFunction<dim>::initialize(const Point<dim> &_center,
+ const double &sigma,
const std::string &func_expr)
{
center = _center;
template <int dim>
inline double
-SigmaFunction<dim>::value(const Point<dim> & p,
+SigmaFunction<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
const Point<dim> d(p - center);
template <int dim>
inline Tensor<1, dim>
-SigmaFunction<dim>::gradient(const Point<dim> & p,
+SigmaFunction<dim>::gradient(const Point<dim> &p,
const unsigned int component) const
{
const Point<dim> d(p - center);
template <int dim>
void
SigmaFunction<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & value_list) const
+ std::vector<double> &value_list) const
{
const unsigned int n_points = points.size();
class SplineEnrichmentFunction : public Function<dim>
{
public:
- SplineEnrichmentFunction(const Point<dim> & origin,
+ SplineEnrichmentFunction(const Point<dim> &origin,
const std::vector<double> &interpolation_points_1d,
const std::vector<double> &interpolation_values_1d)
: Function<dim>(1)
{
ParameterCollection(const std::string &file_name);
- ParameterCollection(const int & dim,
- const double & size,
- const unsigned int & shape,
- const unsigned int & global_refinement,
- const unsigned int & cycles,
- const unsigned int & fe_base_degree,
- const unsigned int & fe_enriched_degree,
- const unsigned int & max_iterations,
- const double & tolerance,
- const std::string & rhs_value_expr,
- const std::string & boundary_value_expr,
- const std::string & rhs_radial_problem,
- const std::string & boundary_radial_problem,
- const std::string & exact_soln_expr,
- const unsigned int & patches,
- const unsigned int & debug_level,
- const unsigned int & n_enrichments,
+ ParameterCollection(const int &dim,
+ const double &size,
+ const unsigned int &shape,
+ const unsigned int &global_refinement,
+ const unsigned int &cycles,
+ const unsigned int &fe_base_degree,
+ const unsigned int &fe_enriched_degree,
+ const unsigned int &max_iterations,
+ const double &tolerance,
+ const std::string &rhs_value_expr,
+ const std::string &boundary_value_expr,
+ const std::string &rhs_radial_problem,
+ const std::string &boundary_radial_problem,
+ const std::string &exact_soln_expr,
+ const unsigned int &patches,
+ const unsigned int &debug_level,
+ const unsigned int &n_enrichments,
const std::vector<double> &points_enrichments,
const std::vector<double> &radii_predicates,
const std::vector<double> &sigmas);
ParameterCollection::ParameterCollection(
- const int & dim,
- const double & size,
- const unsigned int & shape,
- const unsigned int & global_refinement,
- const unsigned int & cycles,
- const unsigned int & fe_base_degree,
- const unsigned int & fe_enriched_degree,
- const unsigned int & max_iterations,
- const double & tolerance,
- const std::string & rhs_value_expr,
- const std::string & boundary_value_expr,
- const std::string & rhs_radial_problem,
- const std::string & boundary_radial_problem,
- const std::string & exact_soln_expr,
- const unsigned int & patches,
- const unsigned int & debug_level,
- const unsigned int & n_enrichments,
+ const int &dim,
+ const double &size,
+ const unsigned int &shape,
+ const unsigned int &global_refinement,
+ const unsigned int &cycles,
+ const unsigned int &fe_base_degree,
+ const unsigned int &fe_enriched_degree,
+ const unsigned int &max_iterations,
+ const double &tolerance,
+ const std::string &rhs_value_expr,
+ const std::string &boundary_value_expr,
+ const std::string &rhs_radial_problem,
+ const std::string &boundary_radial_problem,
+ const std::string &exact_soln_expr,
+ const unsigned int &patches,
+ const unsigned int &debug_level,
+ const unsigned int &n_enrichments,
const std::vector<double> &points_enrichments,
const std::vector<double> &radii_predicates,
const std::vector<double> &sigmas)
class EstimateEnrichmentFunction
{
public:
- EstimateEnrichmentFunction(const Point<1> & center,
- const double & domain_size,
- const double & sigma,
+ EstimateEnrichmentFunction(const Point<1> ¢er,
+ const double &domain_size,
+ const double &sigma,
const std::string &rhs_expr,
const std::string &boundary_expr,
const unsigned int refinement = 11);
- EstimateEnrichmentFunction(const Point<1> & center,
- const double & left_bound,
- const double & right_bound,
- const double & sigma,
+ EstimateEnrichmentFunction(const Point<1> ¢er,
+ const double &left_bound,
+ const double &right_bound,
+ const double &sigma,
const std::string &rhs_expr,
const std::string &boundary_expr,
const unsigned int refinement = 11);
};
EstimateEnrichmentFunction::EstimateEnrichmentFunction(
- const Point<1> & center,
- const double & domain_size,
- const double & sigma,
+ const Point<1> ¢er,
+ const double &domain_size,
+ const double &sigma,
const std::string &rhs_expr,
const std::string &boundary_expr,
const unsigned int refinement)
EstimateEnrichmentFunction::EstimateEnrichmentFunction(
- const Point<1> & center,
- const double & left_bound,
- const double & right_bound,
- const double & sigma,
+ const Point<1> ¢er,
+ const double &left_bound,
+ const double &right_bound,
+ const double &sigma,
const std::string &rhs_expr,
const std::string &boundary_expr,
const unsigned int refinement)
double
-EstimateEnrichmentFunction::value(const Point<1> & p,
+EstimateEnrichmentFunction::value(const Point<1> &p,
const unsigned int &component)
{
return VectorTools::point_value(dof_handler, solution, p);
*/
template <int dim>
void
-check_consistency(const Point<dim> & p,
- const Function<dim> & func,
- const double & v_e,
+check_consistency(const Point<dim> &p,
+ const Function<dim> &func,
+ const double &v_e,
const Tensor<1, dim> &g_e,
const Tensor<2, dim> &h_e,
- const double & v_s0,
+ const double &v_s0,
const Tensor<1, dim> &g_s0,
const Tensor<2, dim> &h_s0,
- const double & v_s1,
+ const double &v_s1,
const Tensor<1, dim> &g_s1,
const Tensor<2, dim> &h_s1)
{
template <int dim>
void
-test(const FiniteElement<dim> & fe1,
- const FiniteElement<dim> & fe2,
- const Quadrature<dim> & volume_quad,
+test(const FiniteElement<dim> &fe1,
+ const FiniteElement<dim> &fe2,
+ const Quadrature<dim> &volume_quad,
const Quadrature<dim - 1> &face_quad,
const bool distort)
{
*/
template <int dim>
void
-check_consistency(const Point<dim> & p,
- const Function<dim> & func1,
- const Function<dim> & func2,
- const Function<dim> & func3,
- const double & v_e,
+check_consistency(const Point<dim> &p,
+ const Function<dim> &func1,
+ const Function<dim> &func2,
+ const Function<dim> &func3,
+ const double &v_e,
const Tensor<1, dim> &g_e,
const Tensor<2, dim> &h_e,
- const double & v_s0,
+ const double &v_s0,
const Tensor<1, dim> &g_s0,
const Tensor<2, dim> &h_s0,
- const double & v_s1,
+ const double &v_s1,
const Tensor<1, dim> &g_s1,
const Tensor<2, dim> &h_s1,
- const double & v_s2,
+ const double &v_s2,
const Tensor<1, dim> &g_s2,
const Tensor<2, dim> &h_s2,
- const double & v_s3,
+ const double &v_s3,
const Tensor<1, dim> &g_s3,
const Tensor<2, dim> &h_s3)
{
*/
template <int dim>
void
-test(const FiniteElement<dim> & fe_base,
- const FiniteElement<dim> & fe_en1,
- const FiniteElement<dim> & fe_en2,
- const Quadrature<dim> & volume_quad,
+test(const FiniteElement<dim> &fe_base,
+ const FiniteElement<dim> &fe_en1,
+ const FiniteElement<dim> &fe_en2,
+ const Quadrature<dim> &volume_quad,
const Quadrature<dim - 1> &face_quad,
const bool distort)
{
{
public:
EnrichmentFunction(const Point<dim> &origin,
- const double & Z,
- const double & radius)
+ const double &Z,
+ const double &radius)
: Function<dim>(1)
, origin(origin)
, Z(Z)
{
public:
EnrichmentFunction(const Point<dim> &origin,
- const double & Z,
- const double & radius)
+ const double &Z,
+ const double &radius)
: Function<dim>(1)
, origin(origin)
, Z(Z)
virtual void
compute_derived_quantities_vector(
- const std::vector<Vector<double>> & solution_values,
+ const std::vector<Vector<double>> &solution_values,
const std::vector<std::vector<Tensor<1, dim>>> &solution_gradients,
const std::vector<std::vector<Tensor<2, dim>>> &solution_hessians,
- const std::vector<Point<dim>> & normals,
- const std::vector<Point<dim>> & evaluation_points,
+ const std::vector<Point<dim>> &normals,
+ const std::vector<Point<dim>> &evaluation_points,
std::vector<Vector<double>> &computed_quantities) const;
private:
const std::vector<std::vector<Tensor<2, dim>>> & /*solution_hessians*/,
const std::vector<Point<dim>> & /*normals*/,
const std::vector<Point<dim>> &evaluation_points,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
const unsigned int n_quadrature_points = solution_values.size();
Assert(computed_quantities.size() == n_quadrature_points,
}
void
-evaluate(const FE_Nedelec<3> & fe,
- const DoFHandler<3> & dof_handler_ref,
+evaluate(const FE_Nedelec<3> &fe,
+ const DoFHandler<3> &dof_handler_ref,
const Vector<double> &u_ref,
- const DoFHandler<3> & dof_handler,
+ const DoFHandler<3> &dof_handler,
const Vector<double> &u)
{
const FEValuesExtractors::Vector component(0);
}
void
-set_solution(Vector<double> & vector,
- const DoFHandler<3> & dof_handler,
- const DoFHandler<3> & dof_handler_ref,
+set_solution(Vector<double> &vector,
+ const DoFHandler<3> &dof_handler,
+ const DoFHandler<3> &dof_handler_ref,
const Vector<double> &u_ref)
{
AffineConstraints<double> constraints;
}
void
-evaluate(const FE_Nedelec<3> & fe,
- const DoFHandler<3> & dof_handler_ref,
+evaluate(const FE_Nedelec<3> &fe,
+ const DoFHandler<3> &dof_handler_ref,
const Vector<double> &u_ref,
- const DoFHandler<3> & dof_handler,
+ const DoFHandler<3> &dof_handler,
const Vector<double> &u)
{
const FEValuesExtractors::Vector component(0);
}
void
-set_solution(Vector<double> & vector,
- const DoFHandler<3> & dof_handler,
- const DoFHandler<3> & dof_handler_ref,
+set_solution(Vector<double> &vector,
+ const DoFHandler<3> &dof_handler,
+ const DoFHandler<3> &dof_handler_ref,
const Vector<double> &u_ref)
{
AffineConstraints<double> constraints;
template <int dim>
inline void
-plot_faces(Mapping<dim> & mapping,
- FiniteElement<dim> & fe,
+plot_faces(Mapping<dim> &mapping,
+ FiniteElement<dim> &fe,
typename DoFHandler<dim>::cell_iterator &cell)
{
// create a QGauss<0>(4), which should
template <int dim>
inline void
-plot_subfaces(Mapping<dim> & mapping,
- FiniteElement<dim> & fe,
+plot_subfaces(Mapping<dim> &mapping,
+ FiniteElement<dim> &fe,
typename DoFHandler<dim>::cell_iterator &cell)
{
// create a QGauss<0>(4), which should
{}
void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const;
+ std::vector<Vector<double>> &values) const;
void
rhs_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const;
+ std::vector<Vector<double>> &values) const;
};
template <int dim>
void
SimplePolynomial<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(dim == 2, ExcNotImplemented());
Assert(values.size() == points.size(),
void
SimplePolynomial<dim>::rhs_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(dim == 2, ExcNotImplemented());
Assert(values.size() == points.size(),
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const;
+ std::vector<Vector<double>> &values) const;
void
curl_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list);
+ std::vector<Vector<double>> &value_list);
};
template <int dim>
void
ExactSolution<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
Assert(value_list.size() == points.size(),
ExcDimensionMismatch(value_list.size(), points.size()));
template <int dim>
void
ExactSolution<dim>::curl_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list)
+ std::vector<Vector<double>> &value_list)
{
Assert(value_list.size() == points.size(),
ExcDimensionMismatch(value_list.size(), points.size()));
template <int dim>
void
VectorFunction<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (int i = 0; i < dim; ++i)
values(i) = value(p, i);
void
create_tria(Triangulation<2> &triangulation,
- const Point<2> * vertices_parallelograms)
+ const Point<2> *vertices_parallelograms)
{
const std::vector<Point<2>> vertices(&vertices_parallelograms[0],
&vertices_parallelograms[n_vertices]);
test(const FiniteElement<dim> &fe,
unsigned n_cycles,
bool global,
- const Point<dim> * vertices_parallelograms)
+ const Point<dim> *vertices_parallelograms)
{
deallog << "dim: " << dim << "\t" << fe.get_name() << std::endl;
deallog << "DoFs\t\t||u-u_h||\tcurl(u_h)\tdiv(u_h)" << std::endl;
template <int dim>
void
VectorFunction<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (int i = 0; i < dim; ++i)
values(i) = value(p, i);
template <>
Tensor<1, 3>
-VectorFunction<3>::gradient(const Point<3> & p,
+VectorFunction<3>::gradient(const Point<3> &p,
const unsigned int component) const
{
const double PI = numbers::PI;
void
create_tria(Triangulation<3> &triangulation,
- const Point<3> * vertices_parallelograms)
+ const Point<3> *vertices_parallelograms)
{
const std::vector<Point<3>> vertices(&vertices_parallelograms[0],
&vertices_parallelograms[n_vertices]);
test(const FiniteElement<dim> &fe,
unsigned n_cycles,
bool global,
- const Point<dim> * vertices_parallelograms)
+ const Point<dim> *vertices_parallelograms)
{
deallog << "dim: " << dim << "\t" << fe.get_name() << std::endl;
deallog
void
divergence_velocity(const BlockVector<double> &calc_solution,
- Vector<double> & output_vector,
- const Quadrature<dim> & quadrature,
+ Vector<double> &output_vector,
+ const Quadrature<dim> &quadrature,
bool norm);
const unsigned int degree;
Triangulation<dim> triangulation;
- FESystem<dim> & fe;
+ FESystem<dim> &fe;
DoFHandler<dim> dof_handler;
AffineConstraints<double> constraints;
template <int dim>
double
- ExactSolution<dim>::value(const Point<dim> & p,
+ ExactSolution<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
template <int dim>
Tensor<1, dim>
- ExactSolution<dim>::gradient(const Point<dim> & p,
+ ExactSolution<dim>::gradient(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
template <int dim>
double
- ExactSolution<dim>::laplacian(const Point<dim> & p,
+ ExactSolution<dim>::laplacian(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
template <int dim>
double
- JumpFunction<dim>::jump(const Point<dim> & p,
+ JumpFunction<dim>::jump(const Point<dim> &p,
const Tensor<1, dim> &normal) const
{
double x = p[0];
template <int dim>
double
- RightHandSide<dim>::value(const Point<dim> & p,
+ RightHandSide<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
template <class Matrix, class Preconditioner>
InverseMatrix<Matrix, Preconditioner>::InverseMatrix(
- const Matrix & m,
+ const Matrix &m,
const Preconditioner &preconditioner)
: matrix(&m)
, preconditioner(&preconditioner)
template <class Matrix, class Preconditioner>
void
- InverseMatrix<Matrix, Preconditioner>::vmult(Vector<double> & dst,
+ InverseMatrix<Matrix, Preconditioner>::vmult(Vector<double> &dst,
const Vector<double> &src) const
{
SolverControl solver_control(src.size(), 1e-6 * src.l2_norm());
{
public:
SchurComplement(
- const BlockSparseMatrix<double> & system_matrix,
+ const BlockSparseMatrix<double> &system_matrix,
const InverseMatrix<SparseMatrix<double>, Preconditioner> &A_inverse);
void
template <class Preconditioner>
SchurComplement<Preconditioner>::SchurComplement(
- const BlockSparseMatrix<double> & system_matrix,
+ const BlockSparseMatrix<double> &system_matrix,
const InverseMatrix<SparseMatrix<double>, Preconditioner> &A_inverse)
: system_matrix(&system_matrix)
, A_inverse(&A_inverse)
template <class Preconditioner>
void
- SchurComplement<Preconditioner>::vmult(Vector<double> & dst,
+ SchurComplement<Preconditioner>::vmult(Vector<double> &dst,
const Vector<double> &src) const
{
system_matrix->block(0, 1).vmult(tmp1, src);
template <int dim>
StokesProblem<dim>::StokesProblem(const unsigned int degree,
- FESystem<dim> & fe_)
+ FESystem<dim> &fe_)
: degree(degree)
, triangulation(Triangulation<dim>::maximum_smoothing)
, fe(fe_)
void
StokesProblem<dim>::divergence_velocity(
const BlockVector<double> &calc_solution,
- Vector<double> & output_vector,
- const Quadrature<dim> & quadrature,
+ Vector<double> &output_vector,
+ const Quadrature<dim> &quadrature,
bool norm)
{
output_vector = 0;
Vector<double> local_dof_values(9);
double dofs[] = {0.0000000000000000e+00,
- 0.0000000000000000e+00,
- 0.0000000000000000e+00,
- 2.3801522930483391e-04,
- 0.0000000000000000e+00,
- 1.1949018981806140e-04,
- 0.0000000000000000e+00,
- 1.1949019042912971e-04,
- 5.9982796422221083e-05};
+ 0.0000000000000000e+00,
+ 0.0000000000000000e+00,
+ 2.3801522930483391e-04,
+ 0.0000000000000000e+00,
+ 1.1949018981806140e-04,
+ 0.0000000000000000e+00,
+ 1.1949019042912971e-04,
+ 5.9982796422221083e-05};
for (unsigned int i = 0; i < 9; ++i)
local_dof_values[i] = dofs[i];
struct MyFESystem
{
MyFESystem(const std::vector<const FiniteElement<dim> *> &fes,
- const std::vector<unsigned int> & multiplicities)
+ const std::vector<unsigned int> &multiplicities)
{
deallog << "Constructing FESystem from list." << std::endl;
}
void
test_projection(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
- std::ostream & out)
+ std::ostream &out)
{
out << fe1.get_name() << " -> " << fe2.get_name() << std::endl;
template <int dim>
void
test(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe1,
- const std::string & fe_string1,
+ const std::string &fe_string1,
const FiniteElement<dim> &fe2,
- const std::string & fe_string2,
+ const std::string &fe_string2,
const unsigned int testcase)
{
DoFHandler<dim> dof_handler1(tria);
AssertThrow(
fe_values[vec_components].symmetric_gradient(i, q) ==
- decltype(
- fe_values[vec_components].symmetric_gradient(i, q))(
+ decltype(fe_values[vec_components].symmetric_gradient(i,
+ q))(
(fe_values[vec_components].gradient(i, q) +
transpose(fe_values[vec_components].gradient(i, q))) /
2),
AssertThrow(
fe_values[vec_components].symmetric_gradient(i, q) ==
- decltype(
- fe_values[vec_components].symmetric_gradient(i, q))(
+ decltype(fe_values[vec_components].symmetric_gradient(
+ i, q))(
(fe_values[vec_components].gradient(i, q) +
transpose(
fe_values[vec_components].gradient(i, q))) /
template <int dim>
void
VectorFunction<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (int i = 0; i < dim; ++i)
values(i) = value(p, i);
template <typename NumberType, int dim, typename ExtractorType>
void
-test_view(const Vector<double> & solution,
- const FEValues<dim> & fe_values,
- const unsigned int & n_q_points,
- const ExtractorType & extractor,
+test_view(const Vector<double> &solution,
+ const FEValues<dim> &fe_values,
+ const unsigned int &n_q_points,
+ const ExtractorType &extractor,
const std::vector<NumberType> &local_dof_values);
// Scalar view
template <typename NumberType, int dim>
void
-test_view(const Vector<double> & solution,
- const FEValues<dim> & fe_values,
- const unsigned int & n_q_points,
+test_view(const Vector<double> &solution,
+ const FEValues<dim> &fe_values,
+ const unsigned int &n_q_points,
const FEValuesExtractors::Scalar &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View = std::remove_reference_t<
std::remove_const_t<decltype(fe_values[extractor])>>;
- const View & fe_values_view = fe_values[extractor];
+ const View &fe_values_view = fe_values[extractor];
const NumberType tolerance = std::is_same_v<NumberType, float> ? 1e-5 : 1e-13;
// Typedefs
// Vector view
template <typename NumberType, int dim>
void
-test_view(const Vector<double> & solution,
- const FEValues<dim> & fe_values,
- const unsigned int & n_q_points,
+test_view(const Vector<double> &solution,
+ const FEValues<dim> &fe_values,
+ const unsigned int &n_q_points,
const FEValuesExtractors::Vector &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View = std::remove_reference_t<
std::remove_const_t<decltype(fe_values[extractor])>>;
- const View & fe_values_view = fe_values[extractor];
+ const View &fe_values_view = fe_values[extractor];
const NumberType tolerance = std::is_same_v<NumberType, float> ? 1e-5 : 1e-13;
// Typedefs
// SymmetricTensor view
template <typename NumberType, int dim>
void
-test_view(const Vector<double> & solution,
- const FEValues<dim> & fe_values,
- const unsigned int & n_q_points,
+test_view(const Vector<double> &solution,
+ const FEValues<dim> &fe_values,
+ const unsigned int &n_q_points,
const FEValuesExtractors::SymmetricTensor<2> &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View = std::remove_reference_t<
std::remove_const_t<decltype(fe_values[extractor])>>;
- const View & fe_values_view = fe_values[extractor];
+ const View &fe_values_view = fe_values[extractor];
const NumberType tolerance = std::is_same_v<NumberType, float> ? 1e-5 : 1e-13;
// Typedefs
// Tensor view
template <typename NumberType, int dim>
void
-test_view(const Vector<double> & solution,
- const FEValues<dim> & fe_values,
- const unsigned int & n_q_points,
+test_view(const Vector<double> &solution,
+ const FEValues<dim> &fe_values,
+ const unsigned int &n_q_points,
const FEValuesExtractors::Tensor<2> &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View = std::remove_reference_t<
std::remove_const_t<decltype(fe_values[extractor])>>;
template <typename NumberType, int dim, typename ExtractorType>
void
-test_view(const Vector<double> & solution,
- const FEValues<dim> & fe_values,
- const unsigned int & n_q_points,
- const ExtractorType & extractor,
+test_view(const Vector<double> &solution,
+ const FEValues<dim> &fe_values,
+ const unsigned int &n_q_points,
+ const ExtractorType &extractor,
const std::vector<NumberType> &local_dof_values);
// Scalar view
template <typename NumberType, int dim>
void
-test_view(const Vector<double> & solution,
- const FEValues<dim> & fe_values,
- const unsigned int & n_q_points,
+test_view(const Vector<double> &solution,
+ const FEValues<dim> &fe_values,
+ const unsigned int &n_q_points,
const FEValuesExtractors::Scalar &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View = std::remove_reference_t<
std::remove_const_t<decltype(fe_values[extractor])>>;
// Vector view
template <typename NumberType, int dim>
void
-test_view(const Vector<double> & solution,
- const FEValues<dim> & fe_values,
- const unsigned int & n_q_points,
+test_view(const Vector<double> &solution,
+ const FEValues<dim> &fe_values,
+ const unsigned int &n_q_points,
const FEValuesExtractors::Vector &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View = std::remove_reference_t<
std::remove_const_t<decltype(fe_values[extractor])>>;
// SymmetricTensor view
template <typename NumberType, int dim>
void
-test_view(const Vector<double> & solution,
- const FEValues<dim> & fe_values,
- const unsigned int & n_q_points,
+test_view(const Vector<double> &solution,
+ const FEValues<dim> &fe_values,
+ const unsigned int &n_q_points,
const FEValuesExtractors::SymmetricTensor<2> &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View = std::remove_reference_t<
std::remove_const_t<decltype(fe_values[extractor])>>;
// Tensor view
template <typename NumberType, int dim>
void
-test_view(const Vector<double> & solution,
- const FEValues<dim> & fe_values,
- const unsigned int & n_q_points,
+test_view(const Vector<double> &solution,
+ const FEValues<dim> &fe_values,
+ const unsigned int &n_q_points,
const FEValuesExtractors::Tensor<2> &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View = std::remove_reference_t<
std::remove_const_t<decltype(fe_values[extractor])>>;
double
difference(const FiniteElement<dim> &fe,
const std::vector<double> dofs,
- const Function<dim> & function)
+ const Function<dim> &function)
{
double result = 0.;
QGauss<dim> quadrature(fe.degree + 1);
double
vector_difference(const FiniteElement<dim> &fe,
const std::vector<double> dofs,
- const Function<dim> & function,
+ const Function<dim> &function,
const unsigned int offset)
{
double result = 0.;
void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int c) const
{
Assert(values.size() == points.size(),
void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int c) const
{
Assert(values.size() == points.size(),
void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
void
plot_diff(const Vector<double> &v1,
const Vector<double> &v2,
- const Tensor<1, 2> & n)
+ const Tensor<1, 2> &n)
{
AssertDimension(v1.size(), 2);
AssertDimension(v2.size(), 2);
void
plot_diff(const Vector<double> &v1,
const Vector<double> &v2,
- const Tensor<1, 3> & n)
+ const Tensor<1, 3> &n)
{
AssertDimension(v1.size(), 3);
AssertDimension(v2.size(), 3);
{}
void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const;
+ std::vector<Vector<double>> &values) const;
void
rhs_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const;
+ std::vector<Vector<double>> &values) const;
};
template <int dim>
void
SimplePolynomial<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(dim == 2, ExcNotImplemented());
Assert(values.size() == points.size(),
void
SimplePolynomial<dim>::rhs_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const
+ std::vector<Vector<double>> &values) const
{
Assert(dim == 2, ExcNotImplemented());
Assert(values.size() == points.size(),
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const;
+ std::vector<Vector<double>> &values) const;
void
curl_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list);
+ std::vector<Vector<double>> &value_list);
};
template <int dim>
void
ExactSolution<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
Assert(value_list.size() == points.size(),
ExcDimensionMismatch(value_list.size(), points.size()));
template <int dim>
void
ExactSolution<dim>::curl_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list)
+ std::vector<Vector<double>> &value_list)
{
Assert(value_list.size() == points.size(),
ExcDimensionMismatch(value_list.size(), points.size()));
void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const override
+ std::vector<Vector<double>> &values) const override
{
for (unsigned int i = 0; i < points.size(); ++i)
{
template <int dim>
void
create_stokes_matrix_1(const DoFHandler<dim> &dof_handler,
- SparseMatrix<double> & A)
+ SparseMatrix<double> &A)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
const unsigned int dofs_per_cell = fe.dofs_per_cell;
template <int dim>
void
create_stokes_matrix_2(const DoFHandler<dim> &dof_handler,
- SparseMatrix<double> & A)
+ SparseMatrix<double> &A)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
const unsigned int dofs_per_cell = fe.dofs_per_cell;
template <int dim>
void
create_stokes_matrix_3(const DoFHandler<dim> &dof_handler,
- SparseMatrix<double> & A)
+ SparseMatrix<double> &A)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
const unsigned int dofs_per_cell = fe.dofs_per_cell;
template <int dim>
void
create_stokes_matrix_2(const DoFHandler<dim> &dof_handler,
- SparseMatrix<double> & A)
+ SparseMatrix<double> &A)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
const unsigned int dofs_per_cell = fe.dofs_per_cell;
template <int dim>
void
create_stokes_matrix_3(const DoFHandler<dim> &dof_handler,
- SparseMatrix<double> & A)
+ SparseMatrix<double> &A)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
const unsigned int dofs_per_cell = fe.dofs_per_cell;
template <int dim>
void
TestMap1<dim>::vector_value(const Point<dim> &p,
- Vector<double> & return_value) const
+ Vector<double> &return_value) const
{
Assert(return_value.size() == this->n_components,
ExcDimensionMismatch(return_value.size(), this->n_components));
template <int dim>
void
TestDef1<dim>::vector_value(const Point<dim> &p,
- Vector<double> & return_value) const
+ Vector<double> &return_value) const
{
Assert(return_value.size() == this->n_components,
ExcDimensionMismatch(return_value.size(), this->n_components));
template <int dim>
void
TestDef2<dim>::vector_value(const Point<dim> &p,
- Vector<double> & return_value) const
+ Vector<double> &return_value) const
{
Assert(return_value.size() == this->n_components,
ExcDimensionMismatch(return_value.size(), this->n_components));
template <int dim>
void
TestDef3<dim>::vector_value(const Point<dim> &p,
- Vector<double> & return_value) const
+ Vector<double> &return_value) const
{
Assert(return_value.size() == this->n_components,
ExcDimensionMismatch(return_value.size(), this->n_components));
template <int dim>
void
TestPoly<dim>::vector_value(const Point<dim> &p,
- Vector<double> & return_value) const
+ Vector<double> &return_value) const
{
Assert(return_value.size() == this->n_components,
ExcDimensionMismatch(return_value.size(), this->n_components));
deallog.get_file_stream() << std::fixed;
Triangulation<2> tria_test;
- DoFHandler<2> * dof_handler, *dof_handler_def;
+ DoFHandler<2> *dof_handler, *dof_handler_def;
Point<2> p1(0, 0), p2(1, 1);
GridGenerator::hyper_rectangle(tria_test, p1, p2);
void
evaluate_normal_component(const DoFHandler<2> &dof_handler,
- Vector<double> & solution)
+ Vector<double> &solution)
{
// This quadrature rule determines the points, where the
// continuity will be tested.
////////////////////////////////////////////////////////////////////////////
template <int dim>
inline void
-plot_shape_functions(Mapping<dim> & mapping,
+plot_shape_functions(Mapping<dim> &mapping,
FiniteElement<dim> &finel,
- const char * name)
+ const char *name)
{
Triangulation<dim> tr;
DoFHandler<dim> dof(tr);
template <int dim>
inline void
-plot_face_shape_functions(Mapping<dim> & mapping,
+plot_face_shape_functions(Mapping<dim> &mapping,
FiniteElement<dim> &finel,
- const char * name,
+ const char *name,
UpdateFlags uflags = UpdateFlags(update_values |
update_gradients |
update_hessians))
template <int dim>
void
check_values_and_derivatives(const FiniteElement<dim> &fe,
- const FEValuesBase<dim> & fe_values,
- const Quadrature<dim> & q)
+ const FEValuesBase<dim> &fe_values,
+ const Quadrature<dim> &q)
{
// check values
for (unsigned int x = 0; x < q.size(); ++x)
template <int dim>
void
-test_compute_functions(const Mapping<dim> & mapping,
+test_compute_functions(const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
const char *)
{
#include "../tests.h"
#include "shapes.h"
-//#include "../../include/fe_bernstein.h"
+// #include "../../include/fe_bernstein.h"
#define PRECISION 8
template <int dim>
inline void
-print_matrix(Triangulation<dim> & tr,
+print_matrix(Triangulation<dim> &tr,
unsigned int level,
const FiniteElement<dim> &finel,
const char * /*name*/)
cell->neighbor(f),
cell->neighbor_of_neighbor(f),
numbers::invalid_unsigned_int);
- const auto & q_points = fe_iv.get_quadrature_points();
+ const auto &q_points = fe_iv.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const unsigned int n_dofs_face = fe_iv.n_current_interface_dofs();
cell->neighbor(f),
cell->neighbor_of_neighbor(f),
numbers::invalid_unsigned_int);
- const auto & q_points = fe_iv.get_quadrature_points();
+ const auto &q_points = fe_iv.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const unsigned int n_dofs_face = fe_iv.n_current_interface_dofs();
template <typename NumberType, int dim, typename ExtractorType>
void
-test_feiv_view(const Vector<double> & solution,
- const FEInterfaceValues<dim> & fe_iv,
- const unsigned int & n_q_points,
- const ExtractorType & extractor,
+test_feiv_view(const Vector<double> &solution,
+ const FEInterfaceValues<dim> &fe_iv,
+ const unsigned int &n_q_points,
+ const ExtractorType &extractor,
const std::vector<NumberType> &local_dof_values);
// Scalar view
template <typename NumberType, int dim>
void
-test_feiv_view(const Vector<double> & solution,
- const FEInterfaceValues<dim> & fe_iv,
- const unsigned int & n_q_points,
+test_feiv_view(const Vector<double> &solution,
+ const FEInterfaceValues<dim> &fe_iv,
+ const unsigned int &n_q_points,
const FEValuesExtractors::Scalar &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View =
std::remove_reference_t<std::remove_const_t<decltype(fe_iv[extractor])>>;
// Vector view
template <typename NumberType, int dim>
void
-test_feiv_view(const Vector<double> & solution,
- const FEInterfaceValues<dim> & fe_iv,
- const unsigned int & n_q_points,
+test_feiv_view(const Vector<double> &solution,
+ const FEInterfaceValues<dim> &fe_iv,
+ const unsigned int &n_q_points,
const FEValuesExtractors::Vector &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View =
std::remove_reference_t<std::remove_const_t<decltype(fe_iv[extractor])>>;
template <typename NumberType, int dim, typename ExtractorType>
void
-test_feiv_view(const Vector<double> & solution,
- const FEValues<dim> & fe_values,
- const unsigned int & n_q_points,
- const ExtractorType & extractor,
+test_feiv_view(const Vector<double> &solution,
+ const FEValues<dim> &fe_values,
+ const unsigned int &n_q_points,
+ const ExtractorType &extractor,
const std::vector<NumberType> &local_dof_values);
// Scalar view
template <typename NumberType, int dim>
void
-test_feiv_view(const Vector<double> & solution,
- const FEInterfaceValues<dim> & fe_iv,
- const unsigned int & n_q_points,
+test_feiv_view(const Vector<double> &solution,
+ const FEInterfaceValues<dim> &fe_iv,
+ const unsigned int &n_q_points,
const FEValuesExtractors::Scalar &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View =
std::remove_reference_t<std::remove_const_t<decltype(fe_iv[extractor])>>;
// Vector view
template <typename NumberType, int dim>
void
-test_feiv_view(const Vector<double> & solution,
- const FEInterfaceValues<dim> & fe_iv,
- const unsigned int & n_q_points,
+test_feiv_view(const Vector<double> &solution,
+ const FEInterfaceValues<dim> &fe_iv,
+ const unsigned int &n_q_points,
const FEValuesExtractors::Vector &extractor,
- const std::vector<NumberType> & local_dof_values)
+ const std::vector<NumberType> &local_dof_values)
{
using View =
std::remove_reference_t<std::remove_const_t<decltype(fe_iv[extractor])>>;
template <int dim>
struct ScratchData
{
- ScratchData(const Mapping<dim> & mapping,
+ ScratchData(const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
const unsigned int quadrature_degree,
const UpdateFlags update_flags = update_values |
template <class MatrixType, class VectorType>
inline void
- copy(const CopyData & c,
+ copy(const CopyData &c,
const AffineConstraints<double> &constraints,
- MatrixType & system_matrix,
- VectorType & system_rhs)
+ MatrixType &system_matrix,
+ VectorType &system_rhs)
{
constraints.distribute_local_to_global(c.cell_matrix,
c.cell_rhs,
BoundaryValues() = default;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
template <int dim>
void
BoundaryValues<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
(void)component;
using Iterator = decltype(dof_handler.begin_active());
BoundaryValues<dim> boundary_function;
- auto cell_worker = [&](const Iterator & cell,
+ auto cell_worker = [&](const Iterator &cell,
ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
const unsigned int n_dofs = scratch_data.fe_values.get_fe().dofs_per_cell;
copy_data.reinit(cell, n_dofs);
scratch_data.fe_values.reinit(cell);
const auto &q_points = scratch_data.fe_values.get_quadrature_points();
- const FEValues<dim> & fe_v = scratch_data.fe_values;
+ const FEValues<dim> &fe_v = scratch_data.fe_values;
const std::vector<double> &JxW = fe_v.get_JxW_values();
for (unsigned int point = 0; point < fe_v.n_quadrature_points; ++point)
}
};
- auto boundary_worker = [&](const Iterator & cell,
+ auto boundary_worker = [&](const Iterator &cell,
const unsigned int &face_no,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
scratch_data.fe_interface_values.reinit(cell, face_no);
const FEFaceValuesBase<dim> &fe_face =
scratch_data.fe_interface_values.get_fe_face_values(0);
const auto &q_points = fe_face.get_quadrature_points();
const unsigned int n_facet_dofs = fe_face.get_fe().n_dofs_per_cell();
- const std::vector<double> & JxW = fe_face.get_JxW_values();
+ const std::vector<double> &JxW = fe_face.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_face.get_normal_vectors();
std::vector<double> g(q_points.size());
}
};
- auto face_worker = [&](const Iterator & cell,
+ auto face_worker = [&](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
FEInterfaceValues<dim> &fe_facet = scratch_data.fe_interface_values;
fe_facet.reinit(cell, f, sf, ncell, nf, nsf);
const auto &q_points = fe_facet.get_quadrature_points();
copy_data_face.cell_matrix.reinit(n_dofs, n_dofs);
- const std::vector<double> & JxW = fe_facet.get_JxW_values();
+ const std::vector<double> &JxW = fe_facet.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals =
fe_facet.get_normal_vectors();
template <class MatrixType, class VectorType>
inline void
- copy(const CopyData & c,
+ copy(const CopyData &c,
const AffineConstraints<double> &constraints,
- MatrixType & system_matrix,
- VectorType & system_rhs)
+ MatrixType &system_matrix,
+ VectorType &system_rhs)
{
constraints.distribute_local_to_global(c.cell_matrix,
c.cell_rhs,
(1.0 / extent1 + 1.0 / extent2);
};
- auto cell_worker = [&](const Iterator & cell,
+ auto cell_worker = [&](const Iterator &cell,
MeshWorker::ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
const FEValues<dim> &fe_v = scratch_data.reinit(cell);
const unsigned int dofs_per_cell = fe_v.dofs_per_cell;
}
};
- auto boundary_worker = [&](const Iterator & cell,
- const unsigned int & face_no,
+ auto boundary_worker = [&](const Iterator &cell,
+ const unsigned int &face_no,
MeshWorker::ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
const FEFaceValuesBase<dim> &fe_fv = scratch_data.reinit(cell, face_no);
const auto &q_points = fe_fv.get_quadrature_points();
- const std::vector<double> & JxW = fe_fv.get_JxW_values();
+ const std::vector<double> &JxW = fe_fv.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_fv.get_normal_vectors();
std::vector<Vector<double>> g_values(q_points.size(),
}
};
- auto face_worker = [&](const Iterator & cell,
- const unsigned int & f,
- const unsigned int & sf,
- const Iterator & ncell,
- const unsigned int & nf,
- const unsigned int & nsf,
+ auto face_worker = [&](const Iterator &cell,
+ const unsigned int &f,
+ const unsigned int &sf,
+ const Iterator &ncell,
+ const unsigned int &nf,
+ const unsigned int &nsf,
MeshWorker::ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
const FEInterfaceValues<dim> &fe_fv =
scratch_data.reinit(cell, f, sf, ncell, nf, nsf);
FEInterfaceViews::Scalar<dim> interface_scalar(fe_fv, pressure.component);
fe_fv, velocities.first_vector_component);
copy_data.face_data.emplace_back();
- CopyDataFace & copy_data_face = copy_data.face_data.back();
+ CopyDataFace ©_data_face = copy_data.face_data.back();
const unsigned int dofs_per_cell = fe_fv.n_current_interface_dofs();
copy_data_face.joint_dof_indices = fe_fv.get_interface_dof_indices();
copy_data_face.cell_matrix.reinit(dofs_per_cell, dofs_per_cell);
- const std::vector<double> & JxW = fe_fv.get_JxW_values();
+ const std::vector<double> &JxW = fe_fv.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_fv.get_normal_vectors();
const auto &q_points = fe_fv.get_quadrature_points();
void
output_grid(
const std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>> &trias,
- const std::string & label)
+ const std::string &label)
{
deallog.push(label);
const auto comm = trias.front()->get_communicator();
template <typename SP>
SparseMatrix(const IndexSet &local,
const IndexSet &,
- SP & sp,
+ SP &sp,
const MPI_Comm comm = MPI_COMM_WORLD)
{}
boost::iostreams::filtering_ostreambuf fosb;
fosb.push(boost::iostreams::back_inserter(buffer));
boost::archive::binary_oarchive oa(fosb);
- oa & cell_ids;
+ oa &cell_ids;
}
{
TimerOutput::Scope t(computing_timer, "boost binary_archive load");
boost::iostreams::filtering_istreambuf fisb;
fisb.push(boost::iostreams::array_source(buffer.data(), buffer.size()));
boost::archive::binary_iarchive ia(fisb);
- ia & deserialized;
+ ia &deserialized;
}
AssertThrow(cell_ids == deserialized,
ExcMessage("Serialization with boost binary archives failed."));
template <int dim>
void
test(const ReferenceCell &reference_cell,
- const Point<dim> & p,
+ const Point<dim> &p,
const bool print = true)
{
const Point<dim> projected = reference_cell.closest_point(p);
template <int dim>
void
-check_found(const Triangulation<dim> & tria,
- const GridTools::Cache<dim> & cache,
+check_found(const Triangulation<dim> &tria,
+ const GridTools::Cache<dim> &cache,
const std::vector<Point<dim>> &points)
{
auto cell_qpoint_map =
create_triangulation(case_no, tria);
const std::pair<Point<dim>, double> smallest_sphere =
tria.begin_active()->enclosing_ball();
- const double & radius = smallest_sphere.second;
+ const double &radius = smallest_sphere.second;
const Point<dim> ¢er = smallest_sphere.first;
deallog << "dim" << dim << ":case" << case_no << ":diameter=" << radius
template <int dim, int spacedim>
void
-print_result(const Mapping<dim, spacedim> & mapping,
+print_result(const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &tria,
const Point<dim> p,
const double tolerance)
template <int dim, int spacedim>
void
-print_result(const Mapping<dim, spacedim> & mapping,
+print_result(const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &tria,
const Point<dim> p,
const double tolerance = 1.e-10)
template <int dim, int spacedim>
void
-print_result(const Mapping<dim, spacedim> & mapping,
+print_result(const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &tria,
const Point<dim> p,
const double tolerance)
template <int dim, int spacedim>
void
-print_result(const Mapping<dim, spacedim> & mapping,
+print_result(const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &tria,
const Point<dim> p,
const double tolerance)
template <int dim, int spacedim>
void
-print_result(const Mapping<dim, spacedim> & mapping,
+print_result(const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &tria,
const Point<dim> p)
{
template <int dim, int spacedim>
void
-print_result(const Mapping<dim, spacedim> & mapping,
+print_result(const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &tria,
const Point<dim> p)
{
void
create_triangulation_with_marching_cube_algorithm(
Triangulation<dim - 1, dim> &tria,
- const Mapping<dim> & mapping,
- const DoFHandler<dim> & background_dof_handler,
- const VectorType & ls_vector,
+ const Mapping<dim> &mapping,
+ const DoFHandler<dim> &background_dof_handler,
+ const VectorType &ls_vector,
const double iso_level,
const unsigned int n_subdivisions,
const double tolerance = 1e-10)
template <int dim>
void
print_mesh_info(const Triangulation<dim> &triangulation,
- const std::string & filename)
+ const std::string &filename)
{
deallog << "Mesh info:" << std::endl
<< " dimension: " << dim << std::endl
template <int dim>
void
print_mesh_info(const Triangulation<dim> &triangulation,
- const std::string & filename)
+ const std::string &filename)
{
deallog << "Mesh info:" << std::endl
<< " dimension: " << dim << std::endl
template <int dim, int spacedim = dim>
void
print_mesh_info(const Triangulation<dim, spacedim> &triangulation,
- const std::string & filename)
+ const std::string &filename)
{
deallog << "Mesh info:" << std::endl
<< " dimension: " << dim << std::endl
template <int dim>
void
output(const parallel::distributed::Triangulation<dim> &tr,
- const std::string & filename,
+ const std::string &filename,
const bool view_levels,
const bool include_artificial)
{
template <int dim>
void
output(const parallel::shared::Triangulation<dim> &tr,
- const std::string & filename,
+ const std::string &filename,
const bool view_levels,
const bool include_artificial)
{
public:
virtual Point<dim>
get_new_point(const ArrayView<const Point<dim>> &surrounding_points,
- const ArrayView<const double> & weights) const override
+ const ArrayView<const double> &weights) const override
{
Point<dim> middle =
FlatManifold<dim>::get_new_point(surrounding_points, weights);
void
test2()
{
- std::ostream & logfile = deallog.get_file_stream();
+ std::ostream &logfile = deallog.get_file_stream();
Triangulation<2> tria;
GridGenerator::hyper_cube(tria);
generate_grid(Triangulation<3> &triangulation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
- Point<3>(+1., -1., -3.),
- Point<3>(-1., +1., -3.),
- Point<3>(+1., +1., -3.),
- Point<3>(-1., -1., -1.),
- Point<3>(+1., -1., -1.),
- Point<3>(-1., +1., -1.),
- Point<3>(+1., +1., -1.),
- Point<3>(-1., -1., +1.),
- Point<3>(+1., -1., +1.),
- Point<3>(-1., +1., +1.),
- Point<3>(+1., +1., +1.),
- Point<3>(-1., -1., +3.),
- Point<3>(+1., -1., +3.),
- Point<3>(-1., +1., +3.),
- Point<3>(+1., +1., +3.)};
+ Point<3>(+1., -1., -3.),
+ Point<3>(-1., +1., -3.),
+ Point<3>(+1., +1., -3.),
+ Point<3>(-1., -1., -1.),
+ Point<3>(+1., -1., -1.),
+ Point<3>(-1., +1., -1.),
+ Point<3>(+1., +1., -1.),
+ Point<3>(-1., -1., +1.),
+ Point<3>(+1., -1., +1.),
+ Point<3>(-1., +1., +1.),
+ Point<3>(+1., +1., +1.),
+ Point<3>(-1., -1., +3.),
+ Point<3>(+1., -1., +3.),
+ Point<3>(-1., +1., +3.),
+ Point<3>(+1., +1., +3.)};
std::vector<Point<3>> vertices(&vertices_1[0], &vertices_1[16]);
std::vector<CellData<3>> cells(2, CellData<3>());
*/
template <typename FaceIterator>
void
-print_match(const FaceIterator & face_1,
- const FaceIterator & face_2,
+print_match(const FaceIterator &face_1,
+ const FaceIterator &face_2,
const std::bitset<3> &orientation)
{
static const int dim = FaceIterator::AccessorType::dimension;
generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
- Point<3>(+1., -1., -3.),
- Point<3>(-1., +1., -3.),
- Point<3>(+1., +1., -3.),
- Point<3>(-1., -1., -1.),
- Point<3>(+1., -1., -1.),
- Point<3>(-1., +1., -1.),
- Point<3>(+1., +1., -1.),
- Point<3>(-1., -1., +1.),
- Point<3>(+1., -1., +1.),
- Point<3>(-1., +1., +1.),
- Point<3>(+1., +1., +1.),
- Point<3>(-1., -1., +3.),
- Point<3>(+1., -1., +3.),
- Point<3>(-1., +1., +3.),
- Point<3>(+1., +1., +3.)};
+ Point<3>(+1., -1., -3.),
+ Point<3>(-1., +1., -3.),
+ Point<3>(+1., +1., -3.),
+ Point<3>(-1., -1., -1.),
+ Point<3>(+1., -1., -1.),
+ Point<3>(-1., +1., -1.),
+ Point<3>(+1., +1., -1.),
+ Point<3>(-1., -1., +1.),
+ Point<3>(+1., -1., +1.),
+ Point<3>(-1., +1., +1.),
+ Point<3>(+1., +1., +1.),
+ Point<3>(-1., -1., +3.),
+ Point<3>(+1., -1., +3.),
+ Point<3>(-1., +1., +3.),
+ Point<3>(+1., +1., +3.)};
std::vector<Point<3>> vertices(&vertices_1[0], &vertices_1[16]);
std::vector<CellData<3>> cells(2, CellData<3>());
*/
template <typename FaceIterator>
void
-print_match(const FaceIterator & face_1,
- const FaceIterator & face_2,
+print_match(const FaceIterator &face_1,
+ const FaceIterator &face_2,
const std::bitset<3> &orientation)
{
static const int dim = FaceIterator::AccessorType::dimension;
std::vector<unsigned int>
mark_vertices_at_boundary(const types::boundary_id boundary_id,
- const Triangulation<2> & triangulation,
- std::vector<bool> & marked_vertices)
+ const Triangulation<2> &triangulation,
+ std::vector<bool> &marked_vertices)
{
std::vector<unsigned int> marked_cell_idxs;
}
int
-find_cell_at_point(const Point<2> & p,
- const Triangulation<2> & triangulation,
+find_cell_at_point(const Point<2> &p,
+ const Triangulation<2> &triangulation,
const std::vector<bool> &marked_vertices,
const Triangulation<2>::active_cell_iterator &cell_hint,
const double tolerance = 1e-6)
// write VTK files for visual inspection
-//#define WRITE_VTK
+// #define WRITE_VTK
#include <deal.II/grid/grid_generator.h>
template <int dim>
double
compute_aspect_ratio_hyper_rectangle(
- const Point<dim> & left,
- const Point<dim> & right,
+ const Point<dim> &left,
+ const Point<dim> &right,
const std::vector<unsigned int> &refinements,
unsigned int degree = 1,
unsigned int n_q_points = 2,
const auto cell_qpoint_map =
GridTools::compute_point_locations(cache, points);
- const auto & cells = std::get<0>(cell_qpoint_map);
- const auto & maps = std::get<2>(cell_qpoint_map);
+ const auto &cells = std::get<0>(cell_qpoint_map);
+ const auto &maps = std::get<2>(cell_qpoint_map);
unsigned int n_cells = cells.size();
for (unsigned int c = 0; c < n_cells; ++c)
// this is not accounted for (for n_cells>5) and the child lines are deleted,
// although they are still needed.
void
-create_star_structured_cylinder(Triangulation<3> & coarse_grid,
+create_star_structured_cylinder(Triangulation<3> &coarse_grid,
const unsigned int n_cells)
{
Assert(n_cells > 1, ExcNotImplemented());
create_two_cubes(Triangulation<3> &coarse_grid)
{
const Point<3> points[6] = {Point<3>(0, 0, 0),
- Point<3>(1, 0, 0),
- Point<3>(1, 1, 0),
- Point<3>(0, 1, 0),
- Point<3>(2, 0, 0),
- Point<3>(2, 1, 0)};
+ Point<3>(1, 0, 0),
+ Point<3>(1, 1, 0),
+ Point<3>(0, 1, 0),
+ Point<3>(2, 0, 0),
+ Point<3>(2, 1, 0)};
std::vector<Point<3>> vertices;
for (unsigned int i = 0; i < 6; ++i)
vertices.push_back(points[i]);
// to store the face rotation (and face flip) in each cell
void
-create_two_cubes_rotation(Triangulation<3> & coarse_grid,
+create_two_cubes_rotation(Triangulation<3> &coarse_grid,
const unsigned int n_rotations)
{
Assert(n_rotations < 4, ExcNotImplemented());
const Point<3> points[6] = {Point<3>(0, 0, 0),
- Point<3>(1, 0, 0),
- Point<3>(1, 1, 0),
- Point<3>(0, 1, 0),
- Point<3>(2, 0, 0),
- Point<3>(2, 1, 0)};
+ Point<3>(1, 0, 0),
+ Point<3>(1, 1, 0),
+ Point<3>(0, 1, 0),
+ Point<3>(2, 0, 0),
+ Point<3>(2, 1, 0)};
std::vector<Point<3>> vertices;
for (unsigned int i = 0; i < 6; ++i)
vertices.push_back(points[i]);
template <int dim>
void
-verify(Triangulation<dim> & tr,
+verify(Triangulation<dim> &tr,
const Vector<float> &criteria,
const float refinement_fraction,
const float coarsening_fraction)
template <int dim, int spacedim>
void
-pre_refinement_notification(const std::string & prefix,
+pre_refinement_notification(const std::string &prefix,
const Triangulation<dim, spacedim> &tria)
{
deallog << prefix << ' ' << "Pre-refinement: " << tria.n_active_cells()
template <int dim, int spacedim>
void
-post_refinement_notification(const std::string & prefix,
+post_refinement_notification(const std::string &prefix,
const Triangulation<dim, spacedim> &tria)
{
deallog << prefix << ' ' << "Post-refinement: " << tria.n_active_cells()
template <int dim, int spacedim>
void
-copy_notification(const std::string & prefix,
+copy_notification(const std::string &prefix,
const Triangulation<dim, spacedim> &old_tria,
const Triangulation<dim, spacedim> &new_tria)
{
template <int dim, int spacedim>
void
-create_notification(const std::string & prefix,
+create_notification(const std::string &prefix,
const Triangulation<dim, spacedim> &tria)
{
deallog << prefix << ' ' << "Create: " << tria.n_active_cells() << std::endl;
template <int dim, int spacedim>
void
-pre_refinement_notification(const std::string & prefix,
+pre_refinement_notification(const std::string &prefix,
const Triangulation<dim, spacedim> &tria)
{
deallog << prefix << ' ' << "Pre-refinement: " << tria.n_active_cells()
template <int dim, int spacedim>
void
-post_refinement_notification(const std::string & prefix,
+post_refinement_notification(const std::string &prefix,
const Triangulation<dim, spacedim> &tria)
{
deallog << prefix << ' ' << "Post-refinement: " << tria.n_active_cells()
template <int dim, int spacedim>
void
-copy_notification(const std::string & prefix,
+copy_notification(const std::string &prefix,
const Triangulation<dim, spacedim> &old_tria,
const Triangulation<dim, spacedim> &new_tria)
{
template <int dim, int spacedim>
void
-create_notification(const std::string & prefix,
+create_notification(const std::string &prefix,
const Triangulation<dim, spacedim> &tria)
{
deallog << prefix << ' ' << "Create: " << tria.n_active_cells() << std::endl;
template <int dim, int spacedim>
void
-any_change_notification(const std::string & prefix,
+any_change_notification(const std::string &prefix,
const Triangulation<dim, spacedim> &tria)
{
deallog << prefix << ' ' << "Any change: " << tria.n_active_cells()
template <int dim>
void
-do_check(const Triangulation<dim> & triangulation,
+do_check(const Triangulation<dim> &triangulation,
const hp::FECollection<dim> &fe)
{
DoFHandler<dim> dof_handler(triangulation);
dofh.begin_active()->set_active_fe_index(1);
dofh.distribute_dofs(fes);
- const auto & parent = dofh.begin(/*level=*/0);
+ const auto &parent = dofh.begin(/*level=*/0);
const unsigned int parent_future_fe =
internal::hp::DoFHandlerImplementation::dominated_future_fe_on_children<
dim>(parent);
template <int dim>
inline void
BoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
values(0) = -0.001;
}
// components the function consists; default - 1
virtual void
vector_value(const Point<dim> &p,
- Vector<double> & values)
+ Vector<double> &values)
const; // returns calculated values in the second argument;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list)
+ std::vector<Vector<double>> &value_list)
const; // values at several points at once
// prevent from calling virtual function "vector_value" to frequently
};
template <int dim>
inline void
ConstrainValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
Assert(values.size() == dim,
ExcDimensionMismatch(values.size(),
void
ConstrainValues<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
Assert(
value_list.size() == points.size(),
template <int dim>
void
project(const hp::FECollection<dim> &fe_collection,
- const hp::QCollection<dim> & q_collection,
- const Function<dim> & function)
+ const hp::QCollection<dim> &q_collection,
+ const Function<dim> &function)
{
#ifdef DEBUG
Assert(fe_collection.size() == 2, ExcInternalError());
};
void
-output(const DoFHandler<2> & dof_handler,
+output(const DoFHandler<2> &dof_handler,
const LinearAlgebra::distributed::Vector<double> &vector,
- const std::string & file_name)
+ const std::string &file_name)
{
DataOut<2> data_out;
data_out.attach_dof_handler(dof_handler);
template <int dim>
void
-do_check(const Triangulation<dim> & triangulation,
+do_check(const Triangulation<dim> &triangulation,
const hp::FECollection<dim> &fe)
{
DoFHandler<dim> dof_handler(triangulation);
// error. we do so with every pair of finite elements given
template <int dim>
void
-test_interpolation_base(const hp::FECollection<dim> & fe,
+test_interpolation_base(const hp::FECollection<dim> &fe,
const std::vector<unsigned int> &polynomial_degrees,
const bool do_refine)
{
template <int dim>
void
-test_interpolation(const hp::FECollection<dim> & fe,
+test_interpolation(const hp::FECollection<dim> &fe,
const std::vector<unsigned int> &polynomial_degrees)
{
test_interpolation_base(fe, polynomial_degrees, false);
template <int dim>
void
-do_check(const Triangulation<dim> & triangulation,
+do_check(const Triangulation<dim> &triangulation,
const hp::FECollection<dim> &fe)
{
DoFHandler<dim> dof_handler(triangulation);
// error. we do so with every pair of finite elements given
template <int dim>
void
-test_interpolation_base(const hp::FECollection<dim> & fe,
+test_interpolation_base(const hp::FECollection<dim> &fe,
const std::vector<unsigned int> &polynomial_degrees,
const bool do_refine)
{
template <int dim>
void
-test_interpolation(const hp::FECollection<dim> & fe,
+test_interpolation(const hp::FECollection<dim> &fe,
const std::vector<unsigned int> &polynomial_degrees)
{
test_interpolation_base(fe, polynomial_degrees, false);
#include "../tests.h"
-//#define DEBUG_OUTPUT_VTK
+// #define DEBUG_OUTPUT_VTK
unsigned int counter = 0;
const double eps = 1e-10;
#include "../tests.h"
-//#define DEBUG_OUTPUT_VTK
+// #define DEBUG_OUTPUT_VTK
unsigned int counter = 0;
const double eps = 1e-10;
less_than_key<dim>());
for (unsigned int p = 0; p < pairs_point_value.size(); ++p)
{
- const Point<dim> & pt = pairs_point_value[p].first;
+ const Point<dim> &pt = pairs_point_value[p].first;
const Vector<double> &val = pairs_point_value[p].second;
Assert(val.size() == n_comp, ExcInternalError());
* The correct constrains are written in a log to make a unit test.
*/
-//#define FEQH_DEBUG_OUTPUT
+// #define FEQH_DEBUG_OUTPUT
template <int dim>
{
hp_fe_values.reinit(cell);
const FEValues<dim> &fe_values = hp_fe_values.get_present_fe_values();
- const unsigned int & dofs_per_cell = fe_values.dofs_per_cell;
+ const unsigned int &dofs_per_cell = fe_values.dofs_per_cell;
local_dof_indices.resize(dofs_per_cell);
cell_matrix.reinit(dofs_per_cell, dofs_per_cell);
-//#define DIRECT
+// #define DIRECT
template <int dim>
void
template <int dim>
void
-check_boundary(const DoFHandler<dim> & dof,
+check_boundary(const DoFHandler<dim> &dof,
const hp::MappingCollection<dim> &mapping)
{
MySquareFunction<dim> coefficient;
template <int dim>
void
-check_boundary(const DoFHandler<dim> & dof,
+check_boundary(const DoFHandler<dim> &dof,
const hp::MappingCollection<dim> &mapping)
{
MySquareFunction<dim> coefficient;
template <typename DH>
void
-initialize_indexsets(IndexSet & locally_owned_dofs,
- IndexSet & locally_relevant_dofs,
+initialize_indexsets(IndexSet &locally_owned_dofs,
+ IndexSet &locally_relevant_dofs,
std::vector<IndexSet> &locally_owned_partitioning,
std::vector<IndexSet> &locally_relevant_partitioning,
- const DH & dof_handler,
+ const DH &dof_handler,
const std::vector<unsigned int> &block_component,
const unsigned int this_mpi_process)
{
public:
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
public:
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
{}
void
value_list(const std::vector<Point<dim>> &points,
- std::vector<Point<dim>> & values) const;
+ std::vector<Point<dim>> &values) const;
};
template <int dim>
void
RHS<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
template <int dim>
void
Beta<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<Point<dim>> & values) const
+ std::vector<Point<dim>> &values) const
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
for (unsigned int i = 0; i < points.size(); ++i)
{
const Point<dim> &p = points[i];
- Point<dim> & beta = values[i];
+ Point<dim> &beta = values[i];
beta(0) = -p(1);
beta(1) = p(0);
template <int dim>
void
BoundaryValues<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
Assert(values.size() == points.size(),
void
assemble_cell_term(const hp::FEValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const;
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const;
void
assemble_boundary_term(const hp::FEFaceValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const;
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const;
template <class X, class Y>
void
- assemble_face_term1(const X & fe_v,
- const Y & fe_v_neighbor,
+ assemble_face_term1(const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix) const;
template <class X, class Y>
void
- assemble_face_term2(const X & fe_v,
- const Y & fe_v_neighbor,
+ assemble_face_term2(const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix,
FullMatrix<double> &ui_ve_matrix,
void
DGTransportEquation<dim>::assemble_boundary_term(
const hp::FEFaceValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const
{
const std::vector<double> &JxW =
fe_v.get_present_fe_values().get_JxW_values();
template <class X, class Y>
void
DGTransportEquation<dim>::assemble_face_term1(
- const X & fe_v,
- const Y & fe_v_neighbor,
+ const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix) const
{
template <class X, class Y>
void
DGTransportEquation<dim>::assemble_face_term2(
- const X & fe_v,
- const Y & fe_v_neighbor,
+ const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix,
FullMatrix<double> &ui_ve_matrix,
virtual void
operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const = 0;
+ const Vector<double> &solution) const = 0;
protected:
unsigned int refinement_cycle;
{
public:
PointValueEvaluation(const Point<dim> &evaluation_point,
- TableHandler & results_table);
+ TableHandler &results_table);
virtual void
operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const;
+ const Vector<double> &solution) const;
DeclException1(ExcEvaluationPointNotFound,
Point<dim>,
private:
const Point<dim> evaluation_point;
- TableHandler & results_table;
+ TableHandler &results_table;
};
template <int dim>
PointValueEvaluation<dim>::PointValueEvaluation(
const Point<dim> &evaluation_point,
- TableHandler & results_table)
+ TableHandler &results_table)
: evaluation_point(evaluation_point)
, results_table(results_table)
{}
template <int dim>
void
PointValueEvaluation<dim>::operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ const Vector<double> &solution) const
{
double point_value = 1e20;
class SolutionOutput : public EvaluationBase<dim>
{
public:
- SolutionOutput(const std::string & output_name_base,
+ SolutionOutput(const std::string &output_name_base,
const DataOutBase::OutputFormat output_format);
virtual void
operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const;
+ const Vector<double> &solution) const;
private:
const std::string output_name_base;
template <int dim>
SolutionOutput<dim>::SolutionOutput(
- const std::string & output_name_base,
+ const std::string &output_name_base,
const DataOutBase::OutputFormat output_format)
: output_name_base(output_name_base)
, output_format(output_format)
template <int dim>
void
SolutionOutput<dim>::operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ const Vector<double> &solution) const
{
DataOut<dim> data_out;
data_out.attach_dof_handler(dof_handler);
class Solver : public virtual Base<dim>
{
public:
- Solver(Triangulation<dim> & triangulation,
+ Solver(Triangulation<dim> &triangulation,
const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature,
- const Function<dim> & boundary_values);
+ const hp::QCollection<dim> &quadrature,
+ const Function<dim> &boundary_values);
virtual ~Solver();
virtual void
void
assemble_matrix(
- LinearSystem & linear_system,
+ LinearSystem &linear_system,
const typename DoFHandler<dim>::active_cell_iterator &begin_cell,
const typename DoFHandler<dim>::active_cell_iterator &end_cell,
- Threads::Mutex & mutex) const;
+ Threads::Mutex &mutex) const;
};
template <int dim>
- Solver<dim>::Solver(Triangulation<dim> & triangulation,
+ Solver<dim>::Solver(Triangulation<dim> &triangulation,
const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature,
- const Function<dim> & boundary_values)
+ const hp::QCollection<dim> &quadrature,
+ const Function<dim> &boundary_values)
: Base<dim>(triangulation)
, fe(&fe)
, quadrature(&quadrature)
template <int dim>
void
Solver<dim>::assemble_matrix(
- LinearSystem & linear_system,
+ LinearSystem &linear_system,
const typename DoFHandler<dim>::active_cell_iterator &begin_cell,
const typename DoFHandler<dim>::active_cell_iterator &end_cell,
- Threads::Mutex & mutex) const
+ Threads::Mutex &mutex) const
{
hp::FEValues<dim> fe_values(*fe,
*quadrature,
class PrimalSolver : public Solver<dim>
{
public:
- PrimalSolver(Triangulation<dim> & triangulation,
+ PrimalSolver(Triangulation<dim> &triangulation,
const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const hp::QCollection<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
protected:
const SmartPointer<const Function<dim>> rhs_function;
template <int dim>
- PrimalSolver<dim>::PrimalSolver(Triangulation<dim> & triangulation,
+ PrimalSolver<dim>::PrimalSolver(Triangulation<dim> &triangulation,
const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values)
+ const hp::QCollection<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values)
: Base<dim>(triangulation)
, Solver<dim>(triangulation, fe, quadrature, boundary_values)
, rhs_function(&rhs_function)
class RefinementGlobal : public PrimalSolver<dim>
{
public:
- RefinementGlobal(Triangulation<dim> & coarse_grid,
+ RefinementGlobal(Triangulation<dim> &coarse_grid,
const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const hp::QCollection<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void
refine_grid();
template <int dim>
RefinementGlobal<dim>::RefinementGlobal(
- Triangulation<dim> & coarse_grid,
+ Triangulation<dim> &coarse_grid,
const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values)
+ const hp::QCollection<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values)
: Base<dim>(coarse_grid)
, PrimalSolver<dim>(coarse_grid,
fe,
class RefinementKelly : public PrimalSolver<dim>
{
public:
- RefinementKelly(Triangulation<dim> & coarse_grid,
+ RefinementKelly(Triangulation<dim> &coarse_grid,
const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature,
- const Function<dim> & rhs_function,
- const Function<dim> & boundary_values);
+ const hp::QCollection<dim> &quadrature,
+ const Function<dim> &rhs_function,
+ const Function<dim> &boundary_values);
virtual void
refine_grid();
template <int dim>
RefinementKelly<dim>::RefinementKelly(Triangulation<dim> &coarse_grid,
const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature,
+ const hp::QCollection<dim> &quadrature,
const Function<dim> &rhs_function,
const Function<dim> &boundary_values)
: Base<dim>(coarse_grid)
template <int dim>
void
run_simulation(
- LaplaceSolver::Base<dim> & solver,
+ LaplaceSolver::Base<dim> &solver,
const std::list<Evaluation::EvaluationBase<dim> *> &postprocessor_list)
{
deallog << "Refinement cycle: ";
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const;
+ std::vector<Vector<double>> &value_list) const;
};
template <int dim>
inline void
RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
Assert(values.size() == dim, ExcDimensionMismatch(values.size(), dim));
Assert(dim >= 2, ExcNotImplemented());
void
RightHandSide<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
Assert(value_list.size() == points.size(),
ExcDimensionMismatch(value_list.size(), points.size()));
public:
LaplaceMatrix();
virtual void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info) const;
virtual void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info) const;
virtual void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
MeshWorker::IntegrationInfo<dim> &info1,
MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
-LaplaceMatrix<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+LaplaceMatrix<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info) const
{
Laplace::cell_matrix(dinfo.matrix(0, false).matrix, info.fe_values(0));
template <int dim>
void
LaplaceMatrix<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().tensor_degree();
template <int dim>
void
-LaplaceMatrix<dim>::face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+LaplaceMatrix<dim>::face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
MeshWorker::IntegrationInfo<dim> &info1,
MeshWorker::IntegrationInfo<dim> &info2) const
{
template <int dim>
void
-assemble_mg_matrix(DoFHandler<dim> & dof_handler,
- MeshWorker::LocalIntegrator<dim> & matrix_integrator,
+assemble_mg_matrix(DoFHandler<dim> &dof_handler,
+ MeshWorker::LocalIntegrator<dim> &matrix_integrator,
mg::SparseMatrixCollection<double> &mg)
{
MGConstrainedDoFs mg_constraints;
template <int dim>
double
-RightHandSide<dim>::value(const Point<dim> & p,
+RightHandSide<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component == 0, ExcNotImplemented());
template <int dim>
double
-BoundaryValues<dim>::value(const Point<dim> & p,
+BoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component == 0, ExcNotImplemented());
template <int dim>
double
-FluxBoundaryValues<dim>::value(const Point<dim> & p,
+FluxBoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
double val = 1; // g = 1
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
SystemIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
// Matrix
const FEValuesBase<dim> &fe = info.fe_values();
- FullMatrix<double> & local_matrix = dinfo.matrix(0).matrix;
+ FullMatrix<double> &local_matrix = dinfo.matrix(0).matrix;
const unsigned int n_points = fe.n_quadrature_points;
const unsigned int n_dofs = fe.dofs_per_cell;
const Advection<dim> advection;
}
// RHS
- Vector<double> & b = dinfo.vector(0).block(0);
+ Vector<double> &b = dinfo.vector(0).block(0);
const RightHandSide<dim> right_hand_side;
for (unsigned int k = 0; k < n_points; ++k)
template <int dim>
void
SystemIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
- const FEValuesBase<dim> & fe = info.fe_values();
+ const FEValuesBase<dim> &fe = info.fe_values();
const unsigned int n_points = fe.n_quadrature_points;
const unsigned int n_dofs = fe.dofs_per_cell;
- Vector<double> & b = dinfo.vector(0).block(0);
+ Vector<double> &b = dinfo.vector(0).block(0);
const FluxBoundaryValues<dim> flux_bd;
for (unsigned int k = 0; k < n_points; ++k)
template <int dim>
void
SystemIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- FullMatrix<double> & A11 = dinfo1.matrix(0, false).matrix;
- FullMatrix<double> & A12 = dinfo1.matrix(0, true).matrix;
- FullMatrix<double> & A21 = dinfo2.matrix(0, true).matrix;
- FullMatrix<double> & A22 = dinfo2.matrix(0, false).matrix;
+ FullMatrix<double> &A11 = dinfo1.matrix(0, false).matrix;
+ FullMatrix<double> &A12 = dinfo1.matrix(0, true).matrix;
+ FullMatrix<double> &A21 = dinfo2.matrix(0, true).matrix;
+ FullMatrix<double> &A22 = dinfo2.matrix(0, false).matrix;
const FEValuesBase<dim> &fe1 = info1.fe_values(0);
const FEValuesBase<dim> &fe2 = info2.fe_values(0);
const unsigned int n_points = fe1.n_quadrature_points;
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
- FullMatrix<double> & local_matrix = dinfo.matrix(0).matrix;
+ FullMatrix<double> &local_matrix = dinfo.matrix(0).matrix;
const unsigned int n_points = fe.n_quadrature_points;
const unsigned int n_dofs = fe.dofs_per_cell;
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{}
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- FullMatrix<double> & A11 = dinfo1.matrix(0, false).matrix;
- FullMatrix<double> & A12 = dinfo1.matrix(0, true).matrix;
- FullMatrix<double> & A21 = dinfo2.matrix(0, true).matrix;
- FullMatrix<double> & A22 = dinfo2.matrix(0, false).matrix;
+ FullMatrix<double> &A11 = dinfo1.matrix(0, false).matrix;
+ FullMatrix<double> &A12 = dinfo1.matrix(0, true).matrix;
+ FullMatrix<double> &A21 = dinfo2.matrix(0, true).matrix;
+ FullMatrix<double> &A22 = dinfo2.matrix(0, false).matrix;
const FEValuesBase<dim> &fe1 = info1.fe_values(0);
const FEValuesBase<dim> &fe2 = info2.fe_values(0);
const unsigned int n_points = fe1.n_quadrature_points;
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
-RHSIntegrator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+RHSIntegrator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
const unsigned int n_points = fe.n_quadrature_points;
const unsigned int n_dofs = fe.dofs_per_cell;
- Vector<double> & b = dinfo.vector(0).block(0);
+ Vector<double> &b = dinfo.vector(0).block(0);
const RightHandSide<dim> right_hand_side;
for (unsigned int k = 0; k < n_points; ++k)
template <int dim>
void
RHSIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
- const FEValuesBase<dim> & fe = info.fe_values();
+ const FEValuesBase<dim> &fe = info.fe_values();
const unsigned int n_points = fe.n_quadrature_points;
const unsigned int n_dofs = fe.dofs_per_cell;
- Vector<double> & b = dinfo.vector(0).block(0);
+ Vector<double> &b = dinfo.vector(0).block(0);
const FluxBoundaryValues<dim> flux_bd;
for (unsigned int k = 0; k < n_points; ++k)
void
face(MeshWorker::DoFInfo<dim> &dinfo1,
MeshWorker::DoFInfo<dim> &dinfo2,
- CellInfo & info1,
- CellInfo & info2) const;
+ CellInfo &info1,
+ CellInfo &info2) const;
};
template <int dim>
void
-cell_matrix(MeshWorker::DoFInfo<dim> & dinfo,
+cell_matrix(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim, dim> &info)
{
unsigned int dm = 0; // Matrix index
void
face(MeshWorker::DoFInfo<dim> &dinfo1,
MeshWorker::DoFInfo<dim> &dinfo2,
- CellInfo & info1,
- CellInfo & info2) const;
+ CellInfo &info1,
+ CellInfo &info2) const;
};
void
face(MeshWorker::DoFInfo<dim> &dinfo1,
MeshWorker::DoFInfo<dim> &dinfo2,
- CellInfo & info1,
- CellInfo & info2) const;
+ CellInfo &info1,
+ CellInfo &info2) const;
bool cells;
bool faces;
SparseMatrix<double> matrix;
Vector<double> v;
- const DoFHandler<dim> & dofs = mgdofs;
+ const DoFHandler<dim> &dofs = mgdofs;
const FiniteElement<dim> &fe = dofs.get_fe();
pattern.reinit(dofs.n_dofs(),
dofs.n_dofs(),
static void
bdry(MeshWorker::DoFInfo<dim> &dinfo, MeshWorker::IntegrationInfo<dim> &info);
static void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
MeshWorker::IntegrationInfo<dim> &info1,
MeshWorker::IntegrationInfo<dim> &info2);
};
template <int dim>
void
-MatrixIntegrator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+MatrixIntegrator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info)
{
const FEValuesBase<dim> &fe = info.fe_values();
- FullMatrix<double> & local_matrix = dinfo.matrix(0).matrix;
+ FullMatrix<double> &local_matrix = dinfo.matrix(0).matrix;
for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
for (unsigned int i = 0; i < fe.dofs_per_cell; ++i)
template <int dim>
void
-MatrixIntegrator<dim>::bdry(MeshWorker::DoFInfo<dim> & dinfo,
+MatrixIntegrator<dim>::bdry(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info)
{
const FEValuesBase<dim> &fe = info.fe_values();
- FullMatrix<double> & local_matrix = dinfo.matrix(0).matrix;
+ FullMatrix<double> &local_matrix = dinfo.matrix(0).matrix;
const unsigned int deg = fe.get_fe().tensor_degree();
const double penalty =
template <int dim>
void
-MatrixIntegrator<dim>::face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+MatrixIntegrator<dim>::face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
MeshWorker::IntegrationInfo<dim> &info1,
MeshWorker::IntegrationInfo<dim> &info2)
{
const FEValuesBase<dim> &fe1 = info1.fe_values();
const FEValuesBase<dim> &fe2 = info2.fe_values();
- FullMatrix<double> & matrix_v1u1 = dinfo1.matrix(0, false).matrix;
- FullMatrix<double> & matrix_v1u2 = dinfo1.matrix(0, true).matrix;
- FullMatrix<double> & matrix_v2u1 = dinfo2.matrix(0, true).matrix;
- FullMatrix<double> & matrix_v2u2 = dinfo2.matrix(0, false).matrix;
+ FullMatrix<double> &matrix_v1u1 = dinfo1.matrix(0, false).matrix;
+ FullMatrix<double> &matrix_v1u2 = dinfo1.matrix(0, true).matrix;
+ FullMatrix<double> &matrix_v2u1 = dinfo2.matrix(0, true).matrix;
+ FullMatrix<double> &matrix_v2u2 = dinfo2.matrix(0, false).matrix;
const unsigned int deg = fe1.get_fe().tensor_degree();
const double penalty1 =
template <int dim>
void
-assemble(const DoFHandler<dim> & dof_handler,
+assemble(const DoFHandler<dim> &dof_handler,
MGLevelObject<SparseMatrix<double>> matrix,
MGLevelObject<SparseMatrix<double>> dg_up,
MGLevelObject<SparseMatrix<double>> dg_down)
SparseMatrix<double> matrix;
Vector<double> v;
- const DoFHandler<dim> & dofs = mgdofs;
+ const DoFHandler<dim> &dofs = mgdofs;
const FiniteElement<dim> &fe = dofs.get_fe();
pattern.reinit(dofs.n_dofs(),
dofs.n_dofs(),
static void
cell(MeshWorker::DoFInfo<dim> &dinfo, MeshWorker::IntegrationInfo<dim> &info);
static void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
MeshWorker::IntegrationInfo<dim> &info1,
MeshWorker::IntegrationInfo<dim> &info2);
static void
- block_cell(MeshWorker::DoFInfo<dim> & dinfo,
+ block_cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info);
static void
- block_face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ block_face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
MeshWorker::IntegrationInfo<dim> &info1,
MeshWorker::IntegrationInfo<dim> &info2);
};
template <int dim>
void
-MatrixIntegrator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+MatrixIntegrator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info)
{
const FiniteElement<dim> &fe = info.fe_values().get_fe();
- FullMatrix<double> & local_matrix = dinfo.matrix(0).matrix;
+ FullMatrix<double> &local_matrix = dinfo.matrix(0).matrix;
for (unsigned int i = 0; i < fe.dofs_per_cell; ++i)
for (unsigned int j = 0; j < fe.dofs_per_cell; ++j)
template <int dim>
void
-MatrixIntegrator<dim>::face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+MatrixIntegrator<dim>::face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
MeshWorker::IntegrationInfo<dim> &info1,
MeshWorker::IntegrationInfo<dim> &info2)
{
const FiniteElement<dim> &fe1 = info1.fe_values().get_fe();
const FiniteElement<dim> &fe2 = info2.fe_values().get_fe();
- FullMatrix<double> & matrix_v1u2 = dinfo1.matrix(0, true).matrix;
- FullMatrix<double> & matrix_v2u1 = dinfo2.matrix(0, true).matrix;
+ FullMatrix<double> &matrix_v1u2 = dinfo1.matrix(0, true).matrix;
+ FullMatrix<double> &matrix_v2u1 = dinfo2.matrix(0, true).matrix;
for (unsigned int i = 0; i < fe1.dofs_per_cell; ++i)
for (unsigned int j = 0; j < fe1.dofs_per_cell; ++j)
template <int dim>
void
-assemble(const DoFHandler<dim> & dof_handler,
+assemble(const DoFHandler<dim> &dof_handler,
MGLevelObject<SparseMatrix<double>> matrix,
MGLevelObject<SparseMatrix<double>> dg_up,
MGLevelObject<SparseMatrix<double>> dg_down)
SparseMatrix<double> matrix;
Vector<double> v;
- const DoFHandler<dim> & dofs = mgdofs;
+ const DoFHandler<dim> &dofs = mgdofs;
const FiniteElement<dim> &fe = dofs.get_fe();
pattern.reinit(dofs.n_dofs(),
dofs.n_dofs(),
setup_system();
void
- integrate_cell_term(MeshWorker::DoFInfo<dim> & dinfo,
+ integrate_cell_term(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info);
void
- integrate_boundary_term(MeshWorker::DoFInfo<dim> & dinfo,
+ integrate_boundary_term(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info);
void
- integrate_face_term(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ integrate_face_term(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
MeshWorker::IntegrationInfo<dim> &info1,
MeshWorker::IntegrationInfo<dim> &info2);
template <int dim>
void
AdvectionProblem<dim>::integrate_cell_term(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info)
{
const FEValuesBase<dim> &fe_v = info.fe_values();
template <int dim>
void
AdvectionProblem<dim>::integrate_boundary_term(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info)
{
const unsigned int boundary_id = dinfo.face->boundary_id();
template <int dim>
void
AdvectionProblem<dim>::integrate_face_term(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
MeshWorker::IntegrationInfo<dim> &info1,
MeshWorker::IntegrationInfo<dim> &info2)
{
void
face(MeshWorker::DoFInfo<dim> &dinfo1,
MeshWorker::DoFInfo<dim> &dinfo2,
- CellInfo & info1,
- CellInfo & info2) const;
+ CellInfo &info1,
+ CellInfo &info2) const;
bool cells;
bool faces;
{
deallog.push("Constructor with iterators");
std::complex<double> array[] = {std::complex<double>(0, 1),
- std::complex<double>(1, 2),
- std::complex<double>(2, 3),
- std::complex<double>(3, 4),
- std::complex<double>(4, 5),
- std::complex<double>(5, 6)};
+ std::complex<double>(1, 2),
+ std::complex<double>(2, 3),
+ std::complex<double>(3, 4),
+ std::complex<double>(4, 5),
+ std::complex<double>(5, 6)};
BlockVector<std::complex<double>> v1(vector_indices, &array[0], &array[6]);
for (unsigned int i = 0; i < v1.size(); ++i)
deallog << v1(i) << ' ';
// other. if step==0, refine back one,
// otherwise the one in front
const Point<3> vertices[12] = {Point<3>(0, 0, 0),
- Point<3>(1, 0, 0),
- Point<3>(1, 0, 1),
- Point<3>(0, 0, 1),
-
- Point<3>(0, 1, 0),
- Point<3>(1, 1, 0),
- Point<3>(1, 1, 1),
- Point<3>(0, 1, 1),
-
- Point<3>(0, 2, 0),
- Point<3>(1, 2, 0),
- Point<3>(1, 2, 1),
- Point<3>(0, 2, 1)};
+ Point<3>(1, 0, 0),
+ Point<3>(1, 0, 1),
+ Point<3>(0, 0, 1),
+
+ Point<3>(0, 1, 0),
+ Point<3>(1, 1, 0),
+ Point<3>(1, 1, 1),
+ Point<3>(0, 1, 1),
+
+ Point<3>(0, 2, 0),
+ Point<3>(1, 2, 0),
+ Point<3>(1, 2, 1),
+ Point<3>(0, 2, 1)};
const int cell_vertices[2][8] = {{0, 1, 2, 3, 4, 5, 6, 7},
- {4, 5, 6, 7, 8, 9, 10, 11}};
+ {4, 5, 6, 7, 8, 9, 10, 11}};
std::vector<CellData<3>> cells(2, CellData<3>());
for (unsigned int cell = 0; cell < 2; ++cell)
for (unsigned int j = 0; j < 8; ++j)
// other. if step==2, refine right one,
// otherwise the left one
const Point<3> vertices[12] = {Point<3>(0, 0, 0),
- Point<3>(1, 0, 0),
- Point<3>(1, 0, 1),
- Point<3>(0, 0, 1),
-
- Point<3>(0, 1, 0),
- Point<3>(1, 1, 0),
- Point<3>(1, 1, 1),
- Point<3>(0, 1, 1),
-
- Point<3>(2, 0, 0),
- Point<3>(2, 0, 1),
- Point<3>(2, 1, 0),
- Point<3>(2, 1, 1)};
+ Point<3>(1, 0, 0),
+ Point<3>(1, 0, 1),
+ Point<3>(0, 0, 1),
+
+ Point<3>(0, 1, 0),
+ Point<3>(1, 1, 0),
+ Point<3>(1, 1, 1),
+ Point<3>(0, 1, 1),
+
+ Point<3>(2, 0, 0),
+ Point<3>(2, 0, 1),
+ Point<3>(2, 1, 0),
+ Point<3>(2, 1, 1)};
const int cell_vertices[2][8] = {{0, 1, 2, 3, 4, 5, 6, 7},
- {1, 8, 9, 2, 5, 10, 11, 6}};
+ {1, 8, 9, 2, 5, 10, 11, 6}};
std::vector<CellData<3>> cells(2, CellData<3>());
for (unsigned int cell = 0; cell < 2; ++cell)
for (unsigned int j = 0; j < 8; ++j)
// other. if step==4, refine top one,
// otherwise the bottom one
const Point<3> vertices[12] = {Point<3>(0, 0, 0),
- Point<3>(1, 0, 0),
- Point<3>(1, 0, 1),
- Point<3>(0, 0, 1),
-
- Point<3>(0, 1, 0),
- Point<3>(1, 1, 0),
- Point<3>(1, 1, 1),
- Point<3>(0, 1, 1),
-
- Point<3>(1, 0, 2),
- Point<3>(0, 0, 2),
- Point<3>(1, 1, 2),
- Point<3>(0, 1, 2)};
+ Point<3>(1, 0, 0),
+ Point<3>(1, 0, 1),
+ Point<3>(0, 0, 1),
+
+ Point<3>(0, 1, 0),
+ Point<3>(1, 1, 0),
+ Point<3>(1, 1, 1),
+ Point<3>(0, 1, 1),
+
+ Point<3>(1, 0, 2),
+ Point<3>(0, 0, 2),
+ Point<3>(1, 1, 2),
+ Point<3>(0, 1, 2)};
const int cell_vertices[2][8] = {{0, 1, 2, 3, 4, 5, 6, 7},
- {3, 2, 8, 9, 7, 6, 10, 11}};
+ {3, 2, 8, 9, 7, 6, 10, 11}};
std::vector<CellData<3>> cells(2, CellData<3>());
for (unsigned int cell = 0; cell < 2; ++cell)
for (unsigned int j = 0; j < 8; ++j)
template <int dim, int spacedim>
void
test(const DoFHandler<dim, spacedim> &dof_handler,
- const IndexSet & locally_relevant_dofs)
+ const IndexSet &locally_relevant_dofs)
{
AffineConstraints<double> constraints;
template <class NUMBER>
void
output_eigenvalues(const std::vector<NUMBER> &eigenvalues,
- const std::string & text)
+ const std::string &text)
{
deallog << text;
for (unsigned int j = 0; j < eigenvalues.size(); ++j)
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
typename VectorType,
class ADDITIONAL_DATA = typename PRECONDITIONER::AdditionalData>
void
-test_preconditioner_block(const MatrixType & A,
- const VectorType & b,
+test_preconditioner_block(const MatrixType &A,
+ const VectorType &b,
const ADDITIONAL_DATA &data = ADDITIONAL_DATA())
{
const auto lo_A = linear_operator<VectorType>(A);
// does not define vector_type
template <class PRECONDITIONER>
void
-test_preconditioner(const SparseMatrix<double> & A,
- const Vector<double> & b,
+test_preconditioner(const SparseMatrix<double> &A,
+ const Vector<double> &b,
const typename PRECONDITIONER::AdditionalData &data =
typename PRECONDITIONER::AdditionalData())
{
class VECTOR,
class ADDITIONAL_DATA = typename PRECONDITIONER::AdditionalData>
void
-test_preconditioner(const MATRIX & A,
- const VECTOR & b,
+test_preconditioner(const MATRIX &A,
+ const VECTOR &b,
const ADDITIONAL_DATA &data = ADDITIONAL_DATA())
{
// This test might trigger spurious floating point exceptions in Trilinos
class VECTOR,
class ADDITIONAL_DATA = typename PRECONDITIONER::AdditionalData>
void
-test_preconditioner(const MATRIX & A,
- const VECTOR & b,
+test_preconditioner(const MATRIX &A,
+ const VECTOR &b,
const ADDITIONAL_DATA &data = ADDITIONAL_DATA())
{
const auto lo_A = linear_operator<VECTOR>(A);
template <int dim>
void
build_matrix_vector(TrilinosWrappers::BlockSparseMatrix &matrix,
- TrilinosWrappers::MPI::BlockVector & vector,
- const FE_Q<dim> & fe_test,
- const FE_Q<dim> & fe_trial)
+ TrilinosWrappers::MPI::BlockVector &vector,
+ const FE_Q<dim> &fe_test,
+ const FE_Q<dim> &fe_trial)
{
deallog.push("build_matrix_vector");
void
evaluate_ops(const TrilinosWrappers::BlockSparseMatrix &matrix,
- const TrilinosWrappers::MPI::BlockVector & vector)
+ const TrilinosWrappers::MPI::BlockVector &vector)
{
const double tol = 1e-12;
using MatrixType = dealii::TrilinosWrappers::SparseMatrix;
template <int dim>
void
build_matrix_vector(TrilinosWrappers::BlockSparseMatrix &matrix,
- TrilinosWrappers::MPI::BlockVector & vector,
- const FE_Q<dim> & fe_test,
- const FE_Q<dim> & fe_trial)
+ TrilinosWrappers::MPI::BlockVector &vector,
+ const FE_Q<dim> &fe_test,
+ const FE_Q<dim> &fe_trial)
{
deallog.push("build_matrix_vector");
void
evaluate_ops(const TrilinosWrappers::BlockSparseMatrix &matrix,
- const TrilinosWrappers::MPI::BlockVector & vector)
+ const TrilinosWrappers::MPI::BlockVector &vector)
{
const double tol = 1e-12;
using MatrixType = dealii::TrilinosWrappers::SparseMatrix;
if (myid > 0)
{
unsigned int local_index = partitioner->global_to_local(1);
- double * values_dev = v.get_values();
+ double *values_dev = v.get_values();
Kokkos::deep_copy(
Kokkos::View<double, MemorySpace::Default::kokkos_space>(values_dev +
local_index),
if (myid == 0)
{
unsigned int local_index = partitioner->global_to_local(1);
- double * values_dev = v.get_values();
+ double *values_dev = v.get_values();
Kokkos::deep_copy(Kokkos::subview(v_device, local_index), 2);
}
if (myid > 0)
{
public:
void
- vmult(VectorType & dst,
+ vmult(VectorType &dst,
const VectorType &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_matrix_vector_product = {},
template <typename VectorType>
void
- vmult(VectorType & dst,
+ vmult(VectorType &dst,
const VectorType &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_matrix_vector_product = {},
{
public:
void
- vmult(VectorType & dst,
+ vmult(VectorType &dst,
const VectorType &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_matrix_vector_product = {},
template <typename VectorType>
void
- vmult(VectorType & dst,
+ vmult(VectorType &dst,
const VectorType &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_matrix_vector_product,
template <typename PreconditionerType, typename VectorType>
std::tuple<double, double, double, double>
test(const PreconditionerType &preconditioner,
- const VectorType & src,
+ const VectorType &src,
const bool test_transposed = true)
{
VectorType dst;
v[4] = 8.;
const auto fun = [&](const Vector<number> &u,
- const number & rho2,
- const number & col_l2_norm2) {
+ const number &rho2,
+ const number &col_l2_norm2) {
deallog << "Linearly dependent column" << std::endl;
deallog << "u:" << std::endl;
u.print(deallog.get_file_stream());
Vector<double> &g = b.block(0);
BlockVector<double> s(blks, rc);
- Vector<double> & x = s.block(1);
- Vector<double> & y = s.block(0);
+ Vector<double> &x = s.block(1);
+ Vector<double> &y = s.block(0);
SolverControl solver_control_A(1, 1.0e-10, false, false);
SolverCG<Vector<double>> solver_A(solver_control_A);
template <int dim>
double
- BoundaryValues<dim>::value(const Point<dim> & p,
+ BoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
template <int dim>
void
BoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = BoundaryValues<dim>::value(p, c);
template <int dim>
void
RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = RightHandSide<dim>::value(p, c);
SolverCG<> solver_S(solver_control_S);
const auto S_inv = inverse_operator(S, solver_S, M_inv);
- Vector<double> & x = solution.block(0);
- Vector<double> & y = solution.block(1);
+ Vector<double> &x = solution.block(0);
+ Vector<double> &y = solution.block(1);
const Vector<double> &f = system_rhs.block(0);
const Vector<double> &g = system_rhs.block(1);
auto rhs = condense_schur_rhs(A_inv, C, f, g);
typename VectorType,
class PRECONDITION>
void
-check_solve(SolverType & solver,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverType &solver,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P)
{
u = 0.;
typename VectorType,
class PRECONDITION>
void
-check_Tsolve(SolverType & solver,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_Tsolve(SolverType &solver,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P)
{
u = 0.;
{}
void
- vmult(LinearAlgebra::distributed::Vector<double> & dst,
+ vmult(LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
dst = src;
void
vmult(
- LinearAlgebra::distributed::Vector<double> & dst,
- const LinearAlgebra::distributed::Vector<double> & src,
+ LinearAlgebra::distributed::Vector<double> &dst,
+ const LinearAlgebra::distributed::Vector<double> &src,
const std::function<void(const unsigned int, const unsigned int)> &before,
const std::function<void(const unsigned int, const unsigned int)> &after)
const
{}
void
- vmult(LinearAlgebra::distributed::Vector<double> & dst,
+ vmult(LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
dst = src;
void
vmult(
- LinearAlgebra::distributed::Vector<double> & dst,
- const LinearAlgebra::distributed::Vector<double> & src,
+ LinearAlgebra::distributed::Vector<double> &dst,
+ const LinearAlgebra::distributed::Vector<double> &src,
const std::function<void(const unsigned int, const unsigned int)> &before,
const std::function<void(const unsigned int, const unsigned int)> &after)
const
template <typename MatrixType, typename VectorType, class PRECONDITION>
void
-check_solve(SolverControl & solver_control,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverControl &solver_control,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P,
const bool expected_result)
{
template <typename MatrixType, typename VectorType, class PRECONDITION>
void
-check_solve(SolverControl & solver_control,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverControl &solver_control,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P,
const bool expected_result)
{
template <typename MatrixType, typename VectorType, class PRECONDITION>
void
-check_solve(SolverControl & solver_control,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverControl &solver_control,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P,
const bool expected_result)
{
template <typename MatrixType, typename VectorType, class PRECONDITION>
void
-check_solve(SolverControl & solver_control,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverControl &solver_control,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P,
const bool expected_result)
{
{}
void
- vmult(LinearAlgebra::distributed::Vector<double> & dst,
+ vmult(LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
dst = src;
}
void
- vmult(LinearAlgebra::distributed::BlockVector<double> & dst,
+ vmult(LinearAlgebra::distributed::BlockVector<double> &dst,
const LinearAlgebra::distributed::BlockVector<double> &src) const
{
dst = src;
template <typename SolverType, typename MatrixType, typename VectorType>
void
-check_solve(const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const typename SolverType::AdditionalData &additional_data =
typename SolverType::AdditionalData())
{
typename VectorType,
class PRECONDITION>
void
-check_solve(SolverType & solver,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverType &solver,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P)
{
u = 0.;
typename VectorType,
class PRECONDITION>
void
-check_solve(SolverType & solver,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverType &solver,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P)
{
u = 0.;
typename VectorType,
class PRECONDITION>
double
-check_solve(SolverType & solver,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverType &solver,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P)
{
double result = 0.;
typename VectorType,
class PRECONDITION>
double
-check_solve(SolverType & solver,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverType &solver,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P)
{
double result = 0.;
typename VectorType,
class PRECONDITION>
double
-check_solve(SolverType & solver,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverType &solver,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P)
{
double result = 0.;
typename VectorType,
class PRECONDITION>
double
-check_solve(SolverType & solver,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverType &solver,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P)
{
double result = 0.;
template <class NUMBER>
void
output_eigenvalues(const std::vector<NUMBER> &eigenvalues,
- const std::string & text)
+ const std::string &text)
{
deallog << text;
for (unsigned int j = 0; j < eigenvalues.size(); ++j)
void
output_arnoldi_vectors_norms(
const internal::SolverGMRESImplementation::TmpVectors<Vector<NUMBER>>
- & tmp_vector,
+ &tmp_vector,
const std::string &text)
{
deallog << text << std::endl;
typename VectorType,
class PRECONDITION>
void
-check_solve(SolverType & solver,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverType &solver,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P)
{
u = 0.;
template <typename MatrixType>
void
check_vmult_quadratic(std::vector<double> &residuals,
- const MatrixType & A,
- const char * prefix)
+ const MatrixType &A,
+ const char *prefix)
{
deallog.push(prefix);
void
-check_vmult_quadratic(std::vector<double> & residuals,
+check_vmult_quadratic(std::vector<double> &residuals,
const BlockSparseMatrix<double> &A,
- const char * prefix)
+ const char *prefix)
{
deallog.push(prefix);
template <int dim, int spacedim>
void
reinit_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_handler,
- SparsityPattern & sparsity_pattern)
+ SparsityPattern &sparsity_pattern)
{
std::vector<unsigned int> counter(dof_handler.n_dofs(), 0);
template <int dim, int spacedim>
void
-reinit_sparsity_pattern(const DoFHandler<dim, spacedim> & dof_handler,
+reinit_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_handler,
TrilinosWrappers::SparsityPattern &sparsity_pattern)
{
sparsity_pattern.reinit(dof_handler.locally_owned_dofs(),
// Compute harminic extent of all non-artificial cells.
template <int dim>
std::vector<std::array<double, dim>>
- compute_harmonic_cell_extent(const Mapping<dim> & mapping,
- const Triangulation<dim> & triangulation,
+ compute_harmonic_cell_extent(const Mapping<dim> &mapping,
+ const Triangulation<dim> &triangulation,
const Quadrature<dim - 1> &quadrature)
{
std::vector<std::array<double, dim>> result(
// of its neighbors. If there is no neigbor, its extent is zero.
template <int dim>
std::vector<dealii::ndarray<double, dim, 3>>
- compute_harmonic_patch_extent(const Mapping<dim> & mapping,
- const Triangulation<dim> & triangulation,
+ compute_harmonic_patch_extent(const Mapping<dim> &mapping,
+ const Triangulation<dim> &triangulation,
const Quadrature<dim - 1> &quadrature)
{
// 1) compute extent of each non-artificial cell
for (unsigned int i = 0; i < w1.size(); ++i)
w1[i] = (2 * i + 1) % 23;
- auto convert_to_vectorized = [](const Vector<double> & in,
+ auto convert_to_vectorized = [](const Vector<double> &in,
AlignedVector<VectorizedArray<double>> &out) {
std::transform(in.begin(), in.end(), out.begin(), [](const double &val) {
return make_vectorized_array(val);
for (unsigned int i = 0; i < macro_size; ++i)
offsets[i] = v1.size() * i;
auto subtract_and_assign =
- [](AlignedVector<VectorizedArray<double>> & lhs,
+ [](AlignedVector<VectorizedArray<double>> &lhs,
const AlignedVector<VectorizedArray<double>> &rhs) {
std::transform(lhs.begin(),
lhs.end(),
for (unsigned int i = 0; i < w1.size(); ++i)
w1[i] = (2 * i + 1) % 23;
- auto convert_to_vectorized = [](const Vector<double> & in,
+ auto convert_to_vectorized = [](const Vector<double> &in,
AlignedVector<VectorizedArray<double>> &out) {
std::transform(in.begin(), in.end(), out.begin(), [](const double &val) {
return make_vectorized_array(val);
for (unsigned int i = 0; i < macro_size; ++i)
offsets[i] = v1.size() * i;
auto subtract_and_assign =
- [](AlignedVector<VectorizedArray<double>> & lhs,
+ [](AlignedVector<VectorizedArray<double>> &lhs,
const AlignedVector<VectorizedArray<double>> &rhs) {
std::transform(lhs.begin(),
lhs.end(),
for (unsigned int i = 0; i < w1.size(); ++i)
w1[i] = (2 * i + 1) % 23;
- auto convert_to_vectorized = [](const Vector<float> & in,
+ auto convert_to_vectorized = [](const Vector<float> &in,
AlignedVector<VectorizedArray<float>> &out) {
std::transform(in.begin(), in.end(), out.begin(), [](const float &val) {
return make_vectorized_array(val);
for (unsigned int i = 0; i < macro_size; ++i)
offsets[i] = v1.size() * i;
auto subtract_and_assign =
- [](AlignedVector<VectorizedArray<float>> & lhs,
+ [](AlignedVector<VectorizedArray<float>> &lhs,
const AlignedVector<VectorizedArray<float>> &rhs) {
std::transform(lhs.begin(),
lhs.end(),
for (unsigned int i = 0; i < w1.size(); ++i)
w1[i] = (2 * i + 1) % 23;
- auto convert_to_vectorized = [](const Vector<double> & in,
+ auto convert_to_vectorized = [](const Vector<double> &in,
AlignedVector<VectorizedArray<double>> &out) {
std::transform(in.begin(), in.end(), out.begin(), [](const double &val) {
return make_vectorized_array(val);
for (unsigned int i = 0; i < macro_size; ++i)
offsets[i] = v1.size() * i;
auto subtract_and_assign =
- [](AlignedVector<VectorizedArray<double>> & lhs,
+ [](AlignedVector<VectorizedArray<double>> &lhs,
const AlignedVector<VectorizedArray<double>> &rhs) {
std::transform(lhs.begin(),
lhs.end(),
*/
-//#define EXTRA_OUTPUT
+// #define EXTRA_OUTPUT
#include <deal.II/lac/diagonal_matrix.h>
test_leak()
{
GrowingVectorMemory<VectorType> mem;
- VectorType * v = mem.alloc();
+ VectorType *v = mem.alloc();
v->reinit(5);
}
test_stat()
{
GrowingVectorMemory<VectorType> mem(1, true);
- VectorType * v1 = mem.alloc();
- VectorType * v2 = mem.alloc();
- VectorType * v3 = mem.alloc();
- VectorType * v4 = mem.alloc();
- VectorType * v5 = mem.alloc();
- VectorType * v6 = mem.alloc();
+ VectorType *v1 = mem.alloc();
+ VectorType *v2 = mem.alloc();
+ VectorType *v3 = mem.alloc();
+ VectorType *v4 = mem.alloc();
+ VectorType *v5 = mem.alloc();
+ VectorType *v6 = mem.alloc();
v1->reinit(5);
v2->reinit(5);
v3->reinit(5);
test_stat()
{
GrowingVectorMemory<VectorType> mem(1, true);
- VectorType * v1 = mem.alloc();
- VectorType * v2 = mem.alloc();
- VectorType * v3 = mem.alloc();
- VectorType * v4 = mem.alloc();
- VectorType * v5 = mem.alloc();
- VectorType * v6 = mem.alloc();
+ VectorType *v1 = mem.alloc();
+ VectorType *v2 = mem.alloc();
+ VectorType *v3 = mem.alloc();
+ VectorType *v4 = mem.alloc();
+ VectorType *v5 = mem.alloc();
+ VectorType *v6 = mem.alloc();
v1->reinit(5);
v2->reinit(5);
v3->reinit(5);
test_leak()
{
GrowingVectorMemory<VectorType> mem;
- VectorType * v = mem.alloc();
+ VectorType *v = mem.alloc();
v->reinit(5);
}
template <class NUMBER>
void
output_eigenvalues(const std::vector<NUMBER> &eigenvalues,
- const std::string & text)
+ const std::string &text)
{
deallog << text;
for (unsigned int j = 0; j < eigenvalues.size(); ++j)
typename VectorType,
class PRECONDITION>
void
-check_solve(SolverType & solver,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_solve(SolverType &solver,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P)
{
u = 0.;
typename VectorType,
class PRECONDITION>
void
-check_Tsolve(SolverType & solver,
- const MatrixType & A,
- VectorType & u,
- VectorType & f,
+check_Tsolve(SolverType &solver,
+ const MatrixType &A,
+ VectorType &u,
+ VectorType &f,
const PRECONDITION &P)
{
u = 0.;
template <int dim>
void
print_intermediate_point(const Manifold<dim> &manifold,
- const std::string & manifold_name,
- const Point<dim> & p1,
- const Point<dim> & p2,
+ const std::string &manifold_name,
+ const Point<dim> &p1,
+ const Point<dim> &p2,
const double weight)
{
const std::vector<Point<dim>> points({p1, p2});
//
void
build_simple_hyper_shell(Triangulation<2, 2> &grid,
- const Point<2> & center,
+ const Point<2> ¢er,
const double inner_radius,
const double outer_radius,
const double eccentricity)
{
unsigned int cell[][4] = {{5, 6, 0, 1},
- {6, 7, 1, 2},
- {8, 3, 7, 2},
- {9, 4, 8, 3},
- {5, 0, 13, 10},
- {13, 10, 14, 11},
- {15, 14, 12, 11},
- {9, 15, 4, 12}};
+ {6, 7, 1, 2},
+ {8, 3, 7, 2},
+ {9, 4, 8, 3},
+ {5, 0, 13, 10},
+ {13, 10, 14, 11},
+ {15, 14, 12, 11},
+ {9, 15, 4, 12}};
std::vector<Point<2>> points =
generate_shell_points(center, inner_radius, outer_radius, eccentricity);
std::vector<CellData<2>> cells(8, CellData<2>());
Point<spacedim>
test_push(const Tensor<1, spacedim> &axis,
const double eccentricity,
- const Point<spacedim> & space_point,
+ const Point<spacedim> &space_point,
unsigned int ref = 1)
{
EllipticalManifold<dim, spacedim> manifold(Point<spacedim>(),
Point<spacedim>
test_pull(const Tensor<1, spacedim> &axis,
const double eccentricity,
- const Point<spacedim> & chart_point,
+ const Point<spacedim> &chart_point,
unsigned int ref = 1)
{
EllipticalManifold<dim, spacedim> manifold(Point<spacedim>(),
void
local_test(const Tensor<1, 2> &axis,
const double eccentricity,
- const Point<2> & space_point)
+ const Point<2> &space_point)
{
const Point<2> pt1 = test_push<2, 2>(axis, eccentricity, space_point);
const Point<2> pt2 = test_pull<2, 2>(axis, eccentricity, pt1);
for (unsigned int i = 0; i < n_iterations; ++i)
{
std::vector<Point<3>> points = {{-.1, -.1, .5},
- {.1, -.1, .5},
- {-.1, .1, .5},
- {.1, .1, .5}};
+ {.1, -.1, .5},
+ {-.1, .1, .5},
+ {.1, .1, .5}};
std::vector<double> weights = {.25, .25, .25, .25};
for (Point<3> &point : points)
};
void
-concentric_disks(Triangulation<2> & tria,
+concentric_disks(Triangulation<2> &tria,
const double s,
const std::vector<double> &x,
- Geom_parameters & gp)
+ Geom_parameters &gp)
{
double r = x[0], d = 0.5 * x[0],
q = 1.0 / sqrt(2.0); // q: corner points factor
}
void
-concentric_disks(Triangulation<2> & tria,
+concentric_disks(Triangulation<2> &tria,
std::vector<double> x,
- Geom_parameters & gp)
+ Geom_parameters &gp)
{
concentric_disks(tria, 0.0, x, gp);
}
template <typename Stream, int dim>
void
-print_triangulation_data(Stream & stream,
+print_triangulation_data(Stream &stream,
const Triangulation<dim> &triangulation)
{
// Boundary id count
template <int dim>
inline void
-plot_faces(Mapping<dim> & mapping,
- FiniteElement<dim> & fe,
+plot_faces(Mapping<dim> &mapping,
+ FiniteElement<dim> &fe,
typename DoFHandler<dim>::cell_iterator &cell)
{
// create a QGauss<0>(4), which should
template <int dim>
inline void
-plot_subfaces(Mapping<dim> & mapping,
- FiniteElement<dim> & fe,
+plot_subfaces(Mapping<dim> &mapping,
+ FiniteElement<dim> &fe,
typename DoFHandler<dim>::cell_iterator &cell)
{
// create a QGauss<0>(4), which should
template <int dim>
inline void
-plot_faces(Mapping<dim> & mapping,
- FiniteElement<dim> & fe,
+plot_faces(Mapping<dim> &mapping,
+ FiniteElement<dim> &fe,
typename DoFHandler<dim>::cell_iterator &cell)
{
// create a QGauss<0>(4), which should
template <int dim>
inline void
-plot_subfaces(Mapping<dim> & mapping,
- FiniteElement<dim> & fe,
+plot_subfaces(Mapping<dim> &mapping,
+ FiniteElement<dim> &fe,
typename DoFHandler<dim>::cell_iterator &cell)
{
// create a QGauss<0>(4), which should
template <int dim>
inline void
-plot_transformation(Mapping<dim> & mapping,
- FiniteElement<dim> & fe,
+plot_transformation(Mapping<dim> &mapping,
+ FiniteElement<dim> &fe,
typename DoFHandler<dim>::cell_iterator &cell,
- const std::string & name)
+ const std::string &name)
{
const unsigned int div = 7;
template <int dim>
inline void
-plot_faces(Mapping<dim> & mapping,
- FiniteElement<dim> & fe,
+plot_faces(Mapping<dim> &mapping,
+ FiniteElement<dim> &fe,
typename DoFHandler<dim>::cell_iterator &cell,
- const std::string & name)
+ const std::string &name)
{
deallog.push(name);
template <int dim>
inline void
-plot_subfaces(Mapping<dim> & mapping,
- FiniteElement<dim> & fe,
+plot_subfaces(Mapping<dim> &mapping,
+ FiniteElement<dim> &fe,
typename DoFHandler<dim>::cell_iterator &cell,
- const std::string & name)
+ const std::string &name)
{
deallog.push(name);
template <int dim>
inline void
-compute_area(Mapping<dim> & mapping,
- FiniteElement<dim> & fe,
+compute_area(Mapping<dim> &mapping,
+ FiniteElement<dim> &fe,
typename DoFHandler<dim>::cell_iterator &cell)
{
QGauss<dim> gauss4(4);
template <>
void
create_triangulations(std::vector<Triangulation<2> *> &tria_ptr,
- std::vector<Manifold<2> *> & boundary_ptr,
- std::vector<double> & exact_areas)
+ std::vector<Manifold<2> *> &boundary_ptr,
+ std::vector<double> &exact_areas)
{
Triangulation<2> *tria;
show.clear();
const double right = 4.;
const Point<2> vertices[4] = {Point<2>(left, left),
- Point<2>(right, left),
- Point<2>(right, right),
- Point<2>(left, right)};
+ Point<2>(right, left),
+ Point<2>(right, right),
+ Point<2>(left, right)};
const int cell_vertices[1][4] = {{1, 2, 0, 3}};
std::vector<CellData<2>> cells(1, CellData<2>());
for (unsigned int j = 0; j < 4; ++j)
template <>
void
create_triangulations(std::vector<Triangulation<3> *> &tria_ptr,
- std::vector<Manifold<3> *> & boundary_ptr,
- std::vector<double> & exact_areas)
+ std::vector<Manifold<3> *> &boundary_ptr,
+ std::vector<double> &exact_areas)
{
Triangulation<3> *tria;
show.clear();
template <int dim, int spacedim>
void
-print_result(const Mapping<dim, spacedim> & mapping,
+print_result(const Mapping<dim, spacedim> &mapping,
const Triangulation<dim, spacedim> &tria,
const Point<dim> p,
const double tolerance)
std::vector<Point<dim>>
get_vertices(const typename Triangulation<dim>::cell_iterator &cell,
const typename Triangulation<dim>::face_iterator &face,
- const Mapping<dim> & mapping)
+ const Mapping<dim> &mapping)
{
std::vector<Point<dim>> vertices(face->n_vertices());
template <int dim, typename Fu>
void
do_test(const unsigned int degree,
- const Fu & fu,
+ const Fu &fu,
const bool is_displacement_function)
{
Triangulation<dim> tria;
void
do_test(const unsigned int degree,
const unsigned int mapping_degree,
- const Fu & fu,
+ const Fu &fu,
const bool is_displacement_function)
{
parallel::distributed::Triangulation<dim> tria(
for (const unsigned int vertex_no : GeometryInfo<dim>::vertex_indices())
if (vertex_touched[cell->vertex_index(vertex_no)] == false)
{
- Point<dim> & v = cell->vertex(vertex_no);
+ Point<dim> &v = cell->vertex(vertex_no);
Tensor<1, dim> d;
for (unsigned int i = 0; i < dim; ++i)
d[i] = displacement_function.value(v, i);
template <int dim>
void
VectorFunction<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (int i = 0; i < dim; ++i)
values(i) = value(p, i);
template <>
Manifold<3> *
ManifoldWrapper<3>::operator()(const Tensor<1, 3> &direction,
- const Point<3> & center) const
+ const Point<3> ¢er) const
{
return new CylindricalManifold<3>(direction, center);
}
template <>
Manifold<3> *
ManifoldWrapper<3>::operator()(const Tensor<1, 3> &direction,
- const Point<3> & center) const
+ const Point<3> ¢er) const
{
return new CylindricalManifold<3>(direction, center);
}
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi(
void
local_apply_face(
- const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi_m(
void
local_apply_boundary_face(
- const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number>
}
}
- const MatrixFree<dim, number> & data;
+ const MatrixFree<dim, number> &data;
const bool zero_within_loop;
const unsigned int start_vector_component;
Tensor<1, dim, VectorizedArray<number>> advection;
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi(
void
local_apply_face(
- const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi_m(
void
local_apply_boundary_face(
- const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number>
}
}
- const MatrixFree<dim, number> & data;
+ const MatrixFree<dim, number> &data;
const bool zero_within_loop;
const unsigned int start_vector_component;
Tensor<1, dim, VectorizedArray<number>> advection;
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi(
void
local_apply_face(
- const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi_m(
void
local_apply_boundary_face(
- const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number>
}
}
- const MatrixFree<dim, number> & data;
+ const MatrixFree<dim, number> &data;
const bool zero_within_loop;
const unsigned int start_vector_component;
Tensor<1, dim, VectorizedArray<number>> advection;
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi(
void
local_apply_face(
- const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi_m(
void
local_apply_boundary_face(
- const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number>
}
}
- const MatrixFree<dim, number> & data;
+ const MatrixFree<dim, number> &data;
const bool zero_within_loop;
const unsigned int start_vector_component;
Tensor<1, dim, VectorizedArray<number>> advection;
template <int dim, int fe_degree>
void
assemble_on_cell(const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim, fe_degree> & data,
+ Assembly::Scratch::Data<dim, fe_degree> &data,
unsigned int &)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
operator()(
const unsigned int cell,
const typename CUDAWrappers::MatrixFree<dim, double>::Data *gpu_data,
- CUDAWrappers::SharedData<dim, double> * shared_data,
- const double * src,
- double * dst) const;
+ CUDAWrappers::SharedData<dim, double> *shared_data,
+ const double *src,
+ double *dst) const;
static const unsigned int n_dofs_1d = fe_degree + 1;
static const unsigned int n_local_dofs =
DummyOperator<dim, fe_degree>::operator()(
const unsigned int cell,
const typename CUDAWrappers::MatrixFree<dim, double>::Data *gpu_data,
- CUDAWrappers::SharedData<dim, double> * shared_data,
+ CUDAWrappers::SharedData<dim, double> *shared_data,
const double *,
double *dst) const
{
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
+ initialize(const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler,
const unsigned int level = numbers::invalid_unsigned_int)
{
void
local_diagonal_face(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const int &,
const std::pair<unsigned int, unsigned int> &face_range) const
void
local_diagonal_boundary(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const int &,
const std::pair<unsigned int, unsigned int> &face_range) const
void
local_diagonal_by_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
template <int dim>
void
BoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
(void)p;
for (unsigned int i = 0; i < values.size(); ++i)
public:
Test(const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free,
- const AffineConstraints<Number> & constraints,
+ const AffineConstraints<Number> &constraints,
const std::function<void(FEEvaluation<dim,
fe_degree,
n_points,
void
cell_operation_range(const MatrixFree<dim, Number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &pair) const
{
FEEvaluation<dim,
}
const MatrixFree<dim, Number, VectorizedArrayType> &matrix_free;
- const AffineConstraints<Number> & constraints;
+ const AffineConstraints<Number> &constraints;
const std::function<void(FEEvaluation<dim,
fe_degree,
n_points,
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
if (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0)
{
Vector<double> solution_gather0(sol.size());
- double * sol_gather_ptr = solution_gather0.begin();
+ double *sol_gather_ptr = solution_gather0.begin();
for (unsigned int i = 0; i < sol.locally_owned_size(); ++i)
*sol_gather_ptr++ = sol.local_element(i);
for (unsigned int i = 1;
}
const unsigned int n_cells = mf_data->n_cell_batches();
- const auto & dof_info = mf_data->get_dof_info();
+ const auto &dof_info = mf_data->get_dof_info();
constexpr unsigned int n_vectorization = VectorizedArray<number>::size();
std::vector<unsigned int> my_rows;
}
const unsigned int n_cells = mf_data->n_cell_batches();
- const auto & dof_info = mf_data->get_dof_info();
+ const auto &dof_info = mf_data->get_dof_info();
constexpr unsigned int n_vectorization = VectorizedArray<number>::size();
std::vector<unsigned int> my_rows;
VectorTools::interpolate(dof_handler, Fu<dim>(), src);
const auto cell_operation = [&](const auto &matrix_free,
- auto & dst,
+ auto &dst,
const auto &src,
const auto range) {
FECellIntegrator phi(matrix_free);
template <int dim, int fe_degree, typename Number>
void
-mass_operator(const MatrixFree<dim, Number> & data,
- Vector<Number> & dst,
- const Vector<Number> & src,
+mass_operator(const MatrixFree<dim, Number> &data,
+ Vector<Number> &dst,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range)
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
local_apply_face(
const MatrixFree<dim, number> &data,
Vector<number> &,
- const Vector<number> & src,
+ const Vector<number> &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, fe_degree + 1, 1, number> ref(data, true);
local_apply_face(
const MatrixFree<dim, number> &data,
Vector<number> &,
- const Vector<number> & src,
+ const Vector<number> &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> ref(data, true);
local_apply_face(
const MatrixFree<dim, number> &data,
Vector<number> &,
- const Vector<number> & src_,
+ const Vector<number> &src_,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, fe_degree + 1, 1, number> ref(data, true);
update_values | update_gradients | update_hessians){};
MatrixFreeTest(const MatrixFree<dim, Number> &data_in,
- const Mapping<dim> & mapping)
+ const Mapping<dim> &mapping)
: data(data_in)
, fe_val(mapping,
data.get_dof_handler().get_fe(),
virtual void
operator()(const MatrixFree<dim, Number> &data,
Vector<Number> &,
- const Vector<Number> & src,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number> fe_eval(data);
template <int dim, int fe_degree, typename number>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints)
{
deallog << "Testing " << dof.get_fe().get_name() << std::endl;
local_apply_boundary_face(
const MatrixFree<dim, number> &data,
Vector<number> &,
- const Vector<number> & src,
+ const Vector<number> &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, fe_degree + 1, 1, number> fe_eval(data,
void
operator()(const MatrixFree<dim, Number> &data,
VectorType &,
- const VectorType & src,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval0(data, 0, 0);
void
operator()(const MatrixFree<dim, Number> &data,
VectorType &,
- const VectorType & src,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, 0, 1, 1, Number> fe_eval0(data, 0, 0);
template <int dim, int fe_degree, int n_q_points_1d, typename number>
void
-sub_test(const DoFHandler<dim> & dof,
+sub_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
- MatrixFree<dim, number> & mf_data,
- Vector<number> & solution)
+ MatrixFree<dim, number> &mf_data,
+ Vector<number> &solution)
{
deallog << "Test with fe_degree " << fe_degree
<< ", n_q_points_1d: " << (n_q_points_1d) << std::endl;
template <int dim, int fe_degree, int n_q_points_1d, typename number>
void
-sub_test(const DoFHandler<dim> & dof,
+sub_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
- MatrixFree<dim, number> & mf_data,
- Vector<number> & solution)
+ MatrixFree<dim, number> &mf_data,
+ Vector<number> &solution)
{
deallog << "Test with fe_degree " << fe_degree
<< ", n_q_points_1d: " << (n_q_points_1d) << std::endl;
: data(data_in){};
void
- operator()(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ operator()(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
MatrixFreeTest<dim, fe_degree, Number>::operator()(
const MatrixFree<dim, Number> &data,
VectorType &,
- const VectorType & src,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
: data(data_in){};
void
- operator()(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ operator()(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
MatrixFreeTest<dim, fe_degree, Number>::operator()(
const MatrixFree<dim, Number> &data,
VectorType &,
- const VectorType & src,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
virtual void
operator()(const MatrixFree<dim, Number> &data,
Vector<Number> &,
- const Vector<Number> & src,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number> fe_eval(data);
template <int dim, int fe_degree, typename number>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints)
{
deallog << "Testing " << dof.get_fe().get_name() << std::endl;
const FEEvaluationData<dim, Number, is_face> &fe_eval,
const bool transpose,
const std::array<dealii::internal::MatrixFreeFunctions::ConstraintKinds,
- Number::size()> & c_mask,
- Number * values)
+ Number::size()> &c_mask,
+ Number *values)
{
Assert(is_face == false, ExcInternalError());
run_2D(
const FEEvaluationData<dim, Number, is_face> &fe_eval,
const std::array<dealii::internal::MatrixFreeFunctions::ConstraintKinds,
- Number::size()> & constraint_mask,
- Number * values)
+ Number::size()> &constraint_mask,
+ Number *values)
{
const auto &constraint_weights = fe_eval.get_shape_info()
.data.front()
run_3D(
const FEEvaluationData<dim, Number, is_face> &fe_eval,
const std::array<dealii::internal::MatrixFreeFunctions::ConstraintKinds,
- Number::size()> & constraint_mask,
- Number * values)
+ Number::size()> &constraint_mask,
+ Number *values)
{
const auto &constraint_weights = fe_eval.get_shape_info()
.data.front()
update_values | update_gradients | update_JxW_values){};
void
- operator()(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ operator()(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
update_JxW_values){};
void
- operator()(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ operator()(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
update_values | update_gradients | update_JxW_values){};
void
- operator()(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ operator()(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
void
MatrixFreeTest<dim, fe_degree, Number>::operator()(
const MatrixFree<dim, Number> &data,
- std::vector<Vector<Number>> & dst,
+ std::vector<Vector<Number>> &dst,
const std::vector<Vector<Number>> &,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
update_values | update_gradients | update_JxW_values){};
void
- operator()(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ operator()(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
void
MatrixFreeTest<dim, fe_degree, Number>::operator()(
const MatrixFree<dim, Number> &data,
- std::vector<Vector<Number>> & dst,
+ std::vector<Vector<Number>> &dst,
const std::vector<Vector<Number>> &,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
: data(data_in){};
MatrixFreeTest(const MatrixFree<dim, Number> &data_in,
- const Mapping<dim> & mapping)
+ const Mapping<dim> &mapping)
: data(data_in){};
virtual ~MatrixFreeTest()
virtual void
cell(const MatrixFree<dim, Number> &data,
Vector<Number> &,
- const Vector<Number> & src,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number> fe_eval(data);
virtual void
face(const MatrixFree<dim, Number> &data,
Vector<Number> &,
- const Vector<Number> & src,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, Number> fe_evalm(data,
virtual void
boundary(const MatrixFree<dim, Number> &data,
Vector<Number> &,
- const Vector<Number> & src,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, Number> fe_evalm(data,
template <int dim, int fe_degree, typename number>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints)
{
deallog << "Testing " << dof.get_fe().get_name() << std::endl;
void
local_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
void
local_inverse_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
void
local_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, dim, Number> fe_eval(data);
void
local_inverse_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, dim, Number> fe_eval(data);
void
local_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 3, Number> fe_eval(data);
void
local_inverse_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 3, Number> fe_eval(data);
void
local_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
void
local_inverse_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
void
local_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
void
local_inverse_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
void
local_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, dim, Number> fe_eval(data);
void
local_inverse_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, dim, Number> fe_eval(data);
void
local_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, -1, 0, 1, Number> fe_eval(data);
void
local_inverse_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, -1, 0, 1, Number> fe_eval(data);
void
local_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, -1, 0, dim, Number> fe_eval(data);
void
local_inverse_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, -1, 0, dim, Number> fe_eval(data);
void
local_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, dim, Number> fe_eval(data);
void
local_inverse_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, dim, Number> fe_eval(data);
void
local_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, -1, 0, dim, Number> fe_eval(data);
void
local_inverse_mass_operator(
- const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, -1, 0, dim, Number> fe_eval(data);
LinearAlgebra::distributed::Vector<double> &,
const LinearAlgebra::distributed::Vector<double> &,
const std::pair<unsigned int, unsigned int> &)>
- cell_func = [](const MatrixFree<dim> & data,
- LinearAlgebra::distributed::Vector<double> & out,
+ cell_func = [](const MatrixFree<dim> &data,
+ LinearAlgebra::distributed::Vector<double> &out,
const LinearAlgebra::distributed::Vector<double> &in,
const std::pair<unsigned int, unsigned int> &range) -> void {
FEEvaluation<dim, fe_degree> eval(data);
const LinearAlgebra::distributed::Vector<double> &,
const std::pair<unsigned int, unsigned int> &)>
boundary_func =
- [](const MatrixFree<dim> & data,
- LinearAlgebra::distributed::Vector<double> & out,
+ [](const MatrixFree<dim> &data,
+ LinearAlgebra::distributed::Vector<double> &out,
const LinearAlgebra::distributed::Vector<double> &in,
- const std::pair<unsigned int, unsigned int> & range) -> void {
+ const std::pair<unsigned int, unsigned int> &range) -> void {
FEFaceEvaluation<dim, fe_degree> eval(data, true);
for (unsigned int face = range.first; face < range.second; ++face)
LinearAlgebra::distributed::Vector<double> &,
const LinearAlgebra::distributed::Vector<double> &,
const std::pair<unsigned int, unsigned int> &)>
- cell_func = [](const MatrixFree<dim> & data,
- LinearAlgebra::distributed::Vector<double> & out,
+ cell_func = [](const MatrixFree<dim> &data,
+ LinearAlgebra::distributed::Vector<double> &out,
const LinearAlgebra::distributed::Vector<double> &in,
const std::pair<unsigned int, unsigned int> &range) -> void {
FEEvaluation<dim, fe_degree> eval(data);
const LinearAlgebra::distributed::Vector<double> &,
const std::pair<unsigned int, unsigned int> &)>
boundary_func =
- [](const MatrixFree<dim> & data,
- LinearAlgebra::distributed::Vector<double> & out,
+ [](const MatrixFree<dim> &data,
+ LinearAlgebra::distributed::Vector<double> &out,
const LinearAlgebra::distributed::Vector<double> &in,
- const std::pair<unsigned int, unsigned int> & range) -> void {
+ const std::pair<unsigned int, unsigned int> &range) -> void {
FEFaceEvaluation<dim, fe_degree> eval(data, true);
for (unsigned int face = range.first; face < range.second; ++face)
template <typename Number>
void
check(const LinearAlgebra::distributed::Vector<Number, MemorySpace::Default>
- & vector,
+ &vector,
const Utilities::MPI::Partitioner &reference_partitioner)
{
Assert(vector.get_partitioner()->locally_owned_range() ==
template <typename Number>
void
check(const LinearAlgebra::CUDAWrappers::Vector<Number> &vector,
- const Utilities::MPI::Partitioner & reference_partitioner)
+ const Utilities::MPI::Partitioner &reference_partitioner)
{
AssertDimension(vector.size(), reference_partitioner.size());
}
fe_degree,
double,
LinearAlgebra::distributed::Vector<double, MemorySpace::Default>,
- n_q_points_1d> & mf,
+ n_q_points_1d> &mf,
unsigned int n_dofs,
- MappingQ<2> & mapping,
+ MappingQ<2> &mapping,
const AffineConstraints<double> &constraints)
{
Vector<double> in_host(n_dofs), out_host(n_dofs);
operator()(
const unsigned int cell,
const typename CUDAWrappers::MatrixFree<dim, Number>::Data *gpu_data,
- CUDAWrappers::SharedData<dim, Number> * shared_data,
- const Number * src,
- Number * dst) const
+ CUDAWrappers::SharedData<dim, Number> *shared_data,
+ const Number *src,
+ Number *dst) const
{
CUDAWrappers::FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number>
fe_eval(gpu_data, shared_data);
template <int dim, int fe_degree, typename number>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints)
{
CUDAWrappers::MatrixFree<dim, number> mf_data;
template <int dim, int fe_degree, typename Number>
void
helmholtz_operator(
- const MatrixFree<dim, Number> & data,
- std::vector<LinearAlgebra::distributed::Vector<Number>> & dst,
+ const MatrixFree<dim, Number> &data,
+ std::vector<LinearAlgebra::distributed::Vector<Number>> &dst,
const std::vector<LinearAlgebra::distributed::Vector<Number>> &src,
- const std::pair<unsigned int, unsigned int> & cell_range)
+ const std::pair<unsigned int, unsigned int> &cell_range)
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 2, Number> fe_eval(data);
const unsigned int n_q_points = fe_eval.n_q_points;
void
vmult(
- std::vector<LinearAlgebra::distributed::Vector<Number>> & dst,
+ std::vector<LinearAlgebra::distributed::Vector<Number>> &dst,
const std::vector<LinearAlgebra::distributed::Vector<Number>> &src) const
{
for (unsigned int i = 0; i < dst.size(); ++i)
template <int dim, int fe_degree, typename Number>
void
-helmholtz_operator(const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+helmholtz_operator(const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range)
{
: data(data_in){};
void
- vmult(LinearAlgebra::distributed::BlockVector<Number> & dst,
+ vmult(LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
dst = 0;
class MatrixFreeTest
{
public:
- MatrixFreeTest(const DoFHandler<dim> & dof_handler,
+ MatrixFreeTest(const DoFHandler<dim> &dof_handler,
const AffineConstraints<double> &constraints)
: dof_handler(dof_handler)
, constraints(constraints)
};
private:
- const DoFHandler<dim> & dof_handler;
+ const DoFHandler<dim> &dof_handler;
const AffineConstraints<double> &constraints;
};
template <int dim, int fe_degree, typename number>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
const unsigned int parallel_option = 0)
{
class MatrixFreeTest
{
public:
- MatrixFreeTest(const DoFHandler<dim> & dof_handler,
+ MatrixFreeTest(const DoFHandler<dim> &dof_handler,
const AffineConstraints<double> &constraints)
: dof_handler(dof_handler)
, constraints(constraints)
};
private:
- const DoFHandler<dim> & dof_handler;
+ const DoFHandler<dim> &dof_handler;
const AffineConstraints<double> &constraints;
};
template <int dim, int fe_degree, typename number>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
const unsigned int parallel_option = 0)
{
const MatrixFree<dim, Number> &data;
void
- local_operation(const MatrixFree<dim, Number> & data,
- VectorType & out,
- const VectorType & in,
+ local_operation(const MatrixFree<dim, Number> &data,
+ VectorType &out,
+ const VectorType &in,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
template <int dim, int fe_degree, typename number>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
const unsigned int parallel_option = 0)
{
template <int dim, int fe_degree, typename Number>
void
-helmholtz_operator(const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+helmholtz_operator(const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range)
{
: data(data_in){};
void
- vmult(LinearAlgebra::distributed::BlockVector<Number> & dst,
+ vmult(LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
for (unsigned int i = 0; i < dst.size(); ++i)
template <int dim, int fe_degree, typename Number>
void
-helmholtz_operator(const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+helmholtz_operator(const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range)
{
: data(data_in){};
void
- vmult(LinearAlgebra::distributed::BlockVector<Number> & dst,
+ vmult(LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
for (unsigned int i = 0; i < dst.size(); ++i)
template <int dim, int fe_degree, typename Number>
void
helmholtz_operator(
- const MatrixFree<dim, Number> & data,
- std::vector<LinearAlgebra::distributed::Vector<Number> *> & dst,
+ const MatrixFree<dim, Number> &data,
+ std::vector<LinearAlgebra::distributed::Vector<Number> *> &dst,
const std::vector<LinearAlgebra::distributed::Vector<Number> *> &src,
- const std::pair<unsigned int, unsigned int> & cell_range)
+ const std::pair<unsigned int, unsigned int> &cell_range)
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 2, Number> fe_eval(data);
const unsigned int n_q_points = fe_eval.n_q_points;
void
vmult(
- std::vector<LinearAlgebra::distributed::Vector<Number> *> & dst,
+ std::vector<LinearAlgebra::distributed::Vector<Number> *> &dst,
const std::vector<LinearAlgebra::distributed::Vector<Number> *> &src) const
{
for (unsigned int i = 0; i < dst.size(); ++i)
template <int dim, int fe_degree, typename Number>
void
helmholtz_operator(
- const MatrixFree<dim, Number> & data,
- std::vector<LinearAlgebra::distributed::Vector<Number> *> & dst,
+ const MatrixFree<dim, Number> &data,
+ std::vector<LinearAlgebra::distributed::Vector<Number> *> &dst,
const std::vector<LinearAlgebra::distributed::Vector<Number> *> &src,
- const std::pair<unsigned int, unsigned int> & cell_range)
+ const std::pair<unsigned int, unsigned int> &cell_range)
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 2, Number> fe_eval(data);
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval2(data);
void
vmult(
- std::vector<LinearAlgebra::distributed::Vector<Number> *> & dst,
+ std::vector<LinearAlgebra::distributed::Vector<Number> *> &dst,
const std::vector<LinearAlgebra::distributed::Vector<Number> *> &src) const
{
for (unsigned int i = 0; i < dst.size(); ++i)
{}
void
- vmult(LinearAlgebra::distributed::BlockVector<Number> & dst,
+ vmult(LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
data.cell_loop(&MatrixFreeBlock::local_apply, this, dst, src, true);
private:
void
- local_apply(const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+ local_apply(const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
template <int dim, int fe_degree, typename number, int n_q_points_1d>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
const unsigned int parallel_option = 0)
{
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
typename VectorType,
int n_q_points_1d>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<Number> &constraints,
const unsigned int n_locally_owned_cells,
const bool constant_coefficient = true,
DEAL_II_HOST_DEVICE
HelmholtzOperatorQuad(
const typename CUDAWrappers::MatrixFree<dim, Number>::Data *gpu_data,
- Number * coef,
+ Number *coef,
int cell)
: gpu_data(gpu_data)
, coef(coef)
DEAL_II_HOST_DEVICE void
operator()(
CUDAWrappers::FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number>
- * fe_eval,
+ *fe_eval,
int q_point) const;
static const unsigned int n_q_points =
private:
const typename CUDAWrappers::MatrixFree<dim, Number>::Data *gpu_data;
- Number * coef;
+ Number *coef;
int cell;
};
operator()(
const unsigned int cell,
const typename CUDAWrappers::MatrixFree<dim, Number>::Data *gpu_data,
- CUDAWrappers::SharedData<dim, Number> * shared_data,
- const Number * src,
- Number * dst) const;
+ CUDAWrappers::SharedData<dim, Number> *shared_data,
+ const Number *src,
+ Number *dst) const;
Number *coef;
};
HelmholtzOperator<dim, fe_degree, Number, n_q_points_1d>::operator()(
const unsigned int cell,
const typename CUDAWrappers::MatrixFree<dim, Number>::Data *gpu_data,
- CUDAWrappers::SharedData<dim, Number> * shared_data,
- const Number * src,
- Number * dst) const
+ CUDAWrappers::SharedData<dim, Number> *shared_data,
+ const Number *src,
+ Number *dst) const
{
CUDAWrappers::FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number> fe_eval(
gpu_data, shared_data);
types::global_dof_index internal_m;
private:
- const CUDAWrappers::MatrixFree<dim, Number> & data;
+ const CUDAWrappers::MatrixFree<dim, Number> &data;
LinearAlgebra::distributed::Vector<double, MemorySpace::Default> coef;
};
int n_q_points_1d>
void
MatrixFreeTest<dim, fe_degree, Number, VectorType, n_q_points_1d>::vmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
dst = static_cast<Number>(0.);
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
- Point<3>(+1., -1., -3.),
- Point<3>(-1., +1., -3.),
- Point<3>(+1., +1., -3.),
- Point<3>(-1., -1., -1.),
- Point<3>(+1., -1., -1.),
- Point<3>(-1., +1., -1.),
- Point<3>(+1., +1., -1.),
- Point<3>(-1., -1., +1.),
- Point<3>(+1., -1., +1.),
- Point<3>(-1., +1., +1.),
- Point<3>(+1., +1., +1.)};
+ Point<3>(+1., -1., -3.),
+ Point<3>(-1., +1., -3.),
+ Point<3>(+1., +1., -3.),
+ Point<3>(-1., -1., -1.),
+ Point<3>(+1., -1., -1.),
+ Point<3>(-1., +1., -1.),
+ Point<3>(+1., +1., -1.),
+ Point<3>(-1., -1., +1.),
+ Point<3>(+1., -1., +1.),
+ Point<3>(-1., +1., +1.),
+ Point<3>(+1., +1., +1.)};
std::vector<Point<3>> vertices(&vertices_1[0], &vertices_1[12]);
std::vector<CellData<3>> cells(2, CellData<3>());
MatrixFree<dim, double> mf_data;
const QGauss<1> quad(n_q_points_1d > 0 ? n_q_points_1d :
- dof.get_fe().degree + 1);
+ dof.get_fe().degree + 1);
typename MatrixFree<dim, double>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, double>::AdditionalData::none;
data.tasks_block_size = 3;
generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
- Point<3>(+1., -1., -3.),
- Point<3>(-1., +1., -3.),
- Point<3>(+1., +1., -3.),
- Point<3>(-1., -1., -1.),
- Point<3>(+1., -1., -1.),
- Point<3>(-1., +1., -1.),
- Point<3>(+1., +1., -1.),
- Point<3>(-1., -1., +1.),
- Point<3>(+1., -1., +1.),
- Point<3>(-1., +1., +1.),
- Point<3>(+1., +1., +1.)};
+ Point<3>(+1., -1., -3.),
+ Point<3>(-1., +1., -3.),
+ Point<3>(+1., +1., -3.),
+ Point<3>(-1., -1., -1.),
+ Point<3>(+1., -1., -1.),
+ Point<3>(-1., +1., -1.),
+ Point<3>(+1., +1., -1.),
+ Point<3>(-1., -1., +1.),
+ Point<3>(+1., -1., +1.),
+ Point<3>(-1., +1., +1.),
+ Point<3>(+1., +1., +1.)};
std::vector<Point<3>> vertices(&vertices_1[0], &vertices_1[12]);
std::vector<CellData<3>> cells(2, CellData<3>());
generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
- Point<3>(+1., -1., -3.),
- Point<3>(-1., +1., -3.),
- Point<3>(+1., +1., -3.),
- Point<3>(-1., -1., -1.),
- Point<3>(+1., -1., -1.),
- Point<3>(-1., +1., -1.),
- Point<3>(+1., +1., -1.),
- Point<3>(-1., -1., +1.),
- Point<3>(+1., -1., +1.),
- Point<3>(-1., +1., +1.),
- Point<3>(+1., +1., +1.)};
+ Point<3>(+1., -1., -3.),
+ Point<3>(-1., +1., -3.),
+ Point<3>(+1., +1., -3.),
+ Point<3>(-1., -1., -1.),
+ Point<3>(+1., -1., -1.),
+ Point<3>(-1., +1., -1.),
+ Point<3>(+1., +1., -1.),
+ Point<3>(-1., -1., +1.),
+ Point<3>(+1., -1., +1.),
+ Point<3>(-1., +1., +1.),
+ Point<3>(+1., +1., +1.)};
std::vector<Point<3>> vertices(&vertices_1[0], &vertices_1[12]);
std::vector<CellData<3>> cells(2, CellData<3>());
private:
void
local_apply(const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim,
void
local_apply_face(
const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim,
fe_degree,
void
local_apply_boundary_face(
const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim,
fe_degree,
private:
void
local_apply(const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim,
void
local_apply_face(
const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim,
fe_degree,
void
local_apply_boundary_face(
const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim,
fe_degree,
private:
void
local_apply(const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim,
void
local_apply_face(
const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim,
fe_degree,
void
local_apply_boundary_face(
const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim,
fe_degree,
template <int dim, int n_components, typename Number>
Tensor<1, n_components, Tensor<1, dim, Number>>
-multiply_by_advection(const Tensor<1, dim, Number> & advection,
+multiply_by_advection(const Tensor<1, dim, Number> &advection,
const Tensor<1, n_components, Number> &values)
{
Tensor<1, n_components, Tensor<1, dim, Number>> out;
template <int dim, typename Number>
Tensor<1, dim, Number>
multiply_by_advection(const Tensor<1, dim, Number> &advection,
- const Number & values)
+ const Number &values)
{
Tensor<1, dim, Number> out;
for (unsigned int d = 0; d < dim; ++d)
private:
void
local_apply(const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim,
void
local_apply_face(
const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim,
fe_degree,
void
local_apply_boundary_face(
const MatrixFree<dim, number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim,
fe_degree,
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().tensor_degree();
typename number,
typename VectorizedArrayType = VectorizedArray<number>>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
const bool also_test_parallel = false)
{
template <int dim>
void
-test_hessians(const dealii::FE_Poly<dim> & fe,
- const dealii::Quadrature<dim> & quad,
+test_hessians(const dealii::FE_Poly<dim> &fe,
+ const dealii::Quadrature<dim> &quad,
const dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
using namespace dealii;
template <int dim>
void
test_hessians(const unsigned int degree,
- const dealii::FE_Poly<dim> & fe,
+ const dealii::FE_Poly<dim> &fe,
const dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
using namespace dealii;
template <int dim>
void
-test_hessians(const dealii::FE_Poly<dim> & fe,
- const dealii::Quadrature<dim> & quad,
+test_hessians(const dealii::FE_Poly<dim> &fe,
+ const dealii::Quadrature<dim> &quad,
const dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
using namespace dealii;
template <int dim>
void
test_hessians(const unsigned int degree,
- const dealii::FE_Poly<dim> & fe,
+ const dealii::FE_Poly<dim> &fe,
const dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
using namespace dealii;
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- Vector<Number> & dst,
- const Vector<Number> & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ Vector<Number> &dst,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
std::pair<unsigned int, unsigned int> subrange_deg =
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- Vector<Number> & dst,
- const Vector<Number> & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ Vector<Number> &dst,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
for (unsigned int i = 1; i <= 9 - 2 * dim; ++i) // skip FE_Nothing
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ local_apply(const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
}
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
dst = 0;
template <int dim, int fe_degree, typename VectorType, int n_q_points_1d>
void
helmholtz_operator(const MatrixFree<dim, typename VectorType::value_type> &data,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range)
{
using Number = typename VectorType::value_type;
void
helmholtz_operator_no_template(
const MatrixFree<dim, typename VectorType::value_type> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & cell_range)
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &cell_range)
{
using Number = typename VectorType::value_type;
FEEvaluation<dim, -1, 0, 1, Number> fe_eval(data, cell_range);
void
helmholtz_operator_no_template(
const MatrixFree<dim, typename VectorType::value_type> &data,
- VectorType & dst,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> & cell_range,
+ VectorType &dst,
+ const VectorType &src,
+ const std::pair<unsigned int, unsigned int> &cell_range,
const unsigned int active_fe_index,
const unsigned int active_quad_index)
{
virtual ~MatrixFreeTest(){};
void
- operator()(const MatrixFree<dim, Number> & data,
- Vector<Number> & dst,
- const Vector<Number> & src,
+ operator()(const MatrixFree<dim, Number> &data,
+ Vector<Number> &dst,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, n_q_points_1d, dim, Number> fe_eval(data);
};
protected:
- const MatrixFree<dim, Number> & data;
+ const MatrixFree<dim, Number> &data;
EvaluationFlags::EvaluationFlags evaluation_flag;
const TestType test_type;
};
template <int dim, int, typename Number>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
const TestType test_type)
{
{}
void
- operator_face(const MatrixFree<dim, Number> & data,
- Vector<Number> & dst,
- const Vector<Number> & src,
+ operator_face(const MatrixFree<dim, Number> &data,
+ Vector<Number> &dst,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, dim, Number> fe_eval(data,
void
operator_boundary(
- const MatrixFree<dim, Number> & data,
- Vector<Number> & dst,
- const Vector<Number> & src,
+ const MatrixFree<dim, Number> &data,
+ Vector<Number> &dst,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, fe_degree, n_q_points_1d, dim, Number> fe_eval(data,
};
protected:
- const MatrixFree<dim, Number> & data;
+ const MatrixFree<dim, Number> &data;
EvaluationFlags::EvaluationFlags evaluation_flag;
const TestType test_type;
};
template <int dim, int fe_degree, typename Number>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints,
const TestType test_type)
{
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
void
local_apply_cell(
- const dealii::MatrixFree<dim, Number> & data,
- BlockVectorType & dst,
- const BlockVectorType & src,
+ const dealii::MatrixFree<dim, Number> &data,
+ BlockVectorType &dst,
+ const BlockVectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
{}
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
void
local_apply(const MatrixFree<dim, Number, VectorizedArrayType> &data,
- VectorType & dst,
- const VectorType & src,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArrayType;
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<Number>;
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
+ 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)
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_apply_face(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval_neighbor(data, false);
void
local_apply_boundary(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
for (unsigned int face = face_range.first; face < face_range.second; ++face)
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
void
local_diagonal_face(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
void
local_diagonal_boundary(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
virtual void
operator()(const unsigned int,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-7, false, false);
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
+ 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)
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
if (!src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_apply_face(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval_neighbor(data, false);
void
local_apply_boundary(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
for (unsigned int face = face_range.first; face < face_range.second; ++face)
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
void
local_diagonal_face(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
void
local_diagonal_boundary(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
virtual void
operator()(const unsigned int,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10, false, false);
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
+ 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)
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
if (!src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_apply_face(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval_neighbor(data, false);
void
local_apply_boundary(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
for (unsigned int face = face_range.first; face < face_range.second; ++face)
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10, false, false);
void
operator()(const MatrixFree<dim, Number> &data,
Vector<Number> &,
- const Vector<Number> & src,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number> fe_eval(data);
template <int dim, int fe_degree, typename number>
void
-do_test(const DoFHandler<dim> & dof,
+do_test(const DoFHandler<dim> &dof,
const AffineConstraints<double> &constraints)
{
// use this for info on problem
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const std::set<types::boundary_id> &dirichlet_boundaries,
const unsigned int level = numbers::invalid_unsigned_int)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const MGConstrainedDoFs &mg_constrained_dofs,
const std::map<types::boundary_id, const Function<dim> *>
- & dirichlet_boundary,
+ &dirichlet_boundary,
const unsigned int level = numbers::invalid_unsigned_int)
{
const QGauss<1> quad(n_q_points_1d);
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_down(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_up(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
Assert(src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
}
void
- vmult(LinearAlgebra::distributed::Vector<double> & dst,
+ vmult(LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
laplace->vmult_interface_down(dst, src);
}
void
- Tvmult(LinearAlgebra::distributed::Vector<double> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
laplace->vmult_interface_up(dst, src);
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const MGConstrainedDoFs &mg_constrained_dofs,
const std::map<types::boundary_id, const Function<dim> *>
- & dirichlet_boundary,
+ &dirichlet_boundary,
const unsigned int level,
const bool threaded)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_down(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_up(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const MGConstrainedDoFs &mg_constrained_dofs,
const std::map<types::boundary_id, const Function<dim> *>
- & dirichlet_boundary,
+ &dirichlet_boundary,
const unsigned int level,
const bool threaded)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_down(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_up(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
}
void
- precondition_Jacobi(BlockVectorType & dst,
+ precondition_Jacobi(BlockVectorType &dst,
const BlockVectorType &src,
const value_type omega) const
{
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
}
void
- precondition_Jacobi(BlockVectorType & dst,
+ precondition_Jacobi(BlockVectorType &dst,
const BlockVectorType &src,
const value_type omega) const
{
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
for (unsigned int i = 0; i < dof.size(); ++i)
{
public:
void
initialize(std::shared_ptr<const MatrixFree<dim, Number>> data,
- const MGConstrainedDoFs & mg_constrained_dofs,
+ const MGConstrainedDoFs &mg_constrained_dofs,
const unsigned int level)
{
MatrixFreeOperators::Base<dim, LinearAlgebra::distributed::Vector<Number>>::
void
initialize(std::shared_ptr<const MatrixFree<dim, Number>> data,
- const std::vector<unsigned int> & mask = {})
+ const std::vector<unsigned int> &mask = {})
{
MatrixFreeOperators::Base<dim, LinearAlgebra::distributed::Vector<Number>>::
initialize(data, mask);
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
adjust_ghost_range_if_necessary(src);
private:
void
- local_apply(const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ local_apply(const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const std::set<types::boundary_id> &dirichlet_boundaries,
const unsigned int level = numbers::invalid_unsigned_int)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
}
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const std::set<types::boundary_id> &dirichlet_boundaries,
const unsigned int level = numbers::invalid_unsigned_int)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src, true);
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src);
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
}
void
- initialize(const Mapping<dim> & mapping,
- DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ DoFHandler<dim> &dof_handler,
const std::set<types::boundary_id> &dirichlet_boundaries,
const unsigned int level = numbers::invalid_unsigned_int)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src, true);
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src);
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const std::set<types::boundary_id> &dirichlet_boundaries,
const unsigned int level = numbers::invalid_unsigned_int)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
void
dummy_operation_1(const MatrixFree<dim, Number, VectorizedArrayType> &,
- VectorType & dst,
+ VectorType &dst,
const VectorType &src,
const std::pair<unsigned int, unsigned int> &) const
{
generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-0., -0., -0.),
- Point<3>(+1., -0., -0.),
- Point<3>(-0., +1., -0.),
- Point<3>(+1., +1., -0.),
- Point<3>(-0., -0., +0.5),
- Point<3>(+1., -0., +0.5),
- Point<3>(-0., +1., +0.5),
- Point<3>(+1., +1., +0.5),
- Point<3>(-0., -0., +1.),
- Point<3>(+1., -0., +1.),
- Point<3>(-0., +1., +1.),
- Point<3>(+1., +1., +1.)};
+ Point<3>(+1., -0., -0.),
+ Point<3>(-0., +1., -0.),
+ Point<3>(+1., +1., -0.),
+ Point<3>(-0., -0., +0.5),
+ Point<3>(+1., -0., +0.5),
+ Point<3>(-0., +1., +0.5),
+ Point<3>(+1., +1., +0.5),
+ Point<3>(-0., -0., +1.),
+ Point<3>(+1., -0., +1.),
+ Point<3>(-0., +1., +1.),
+ Point<3>(+1., +1., +1.)};
std::vector<Point<3>> vertices(&vertices_1[0], &vertices_1[12]);
std::vector<CellData<3>> cells(2, CellData<3>());
generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-0., -0., -0.),
- Point<3>(+1., -0., -0.),
- Point<3>(-0., +1., -0.),
- Point<3>(+1., +1., -0.),
- Point<3>(-0., -0., +0.5),
- Point<3>(+1., -0., +0.5),
- Point<3>(-0., +1., +0.5),
- Point<3>(+1., +1., +0.5),
- Point<3>(-0., -0., +1.),
- Point<3>(+1., -0., +1.),
- Point<3>(-0., +1., +1.),
- Point<3>(+1., +1., +1.)};
+ Point<3>(+1., -0., -0.),
+ Point<3>(-0., +1., -0.),
+ Point<3>(+1., +1., -0.),
+ Point<3>(-0., -0., +0.5),
+ Point<3>(+1., -0., +0.5),
+ Point<3>(-0., +1., +0.5),
+ Point<3>(+1., +1., +0.5),
+ Point<3>(-0., -0., +1.),
+ Point<3>(+1., -0., +1.),
+ Point<3>(-0., +1., +1.),
+ Point<3>(+1., +1., +1.)};
std::vector<Point<3>> vertices(&vertices_1[0], &vertices_1[12]);
std::vector<CellData<3>> cells(2, CellData<3>());
const auto solve_and_postprocess =
[&](const auto &poisson_operator,
- auto & x,
- auto & b) -> std::pair<unsigned int, double> {
+ auto &x,
+ auto &b) -> std::pair<unsigned int, double> {
ReductionControl reduction_control(2000, 1e-7, 1e-2);
SolverCG<std::remove_reference_t<decltype(x)>> solver(reduction_control);
{}
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const std::function<void(const MatrixFree<dim, Number> &,
{}
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const std::function<void(const MatrixFree<dim, Number> &,
{}
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const std::function<void(const MatrixFree<dim, Number> &,
{}
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
dst = 0;
void
local_apply(const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & range) const
+ const std::pair<unsigned int, unsigned int> &range) const
{
helmholtz_operator<dim,
fe_degree,
{}
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
dst = 0;
void
local_apply(const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & range) const
+ const std::pair<unsigned int, unsigned int> &range) const
{
FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number> fe_eval(data, 1);
{}
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const std::function<void(const MatrixFree<dim, Number> &,
const std::pair<unsigned int, unsigned int> &) {};
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
const std::function<void(const MatrixFree<dim, Number> &,
const std::pair<unsigned int, unsigned int> &) const {};
void
- do_boundary(const MatrixFree<dim, Number> & mf,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ do_boundary(const MatrixFree<dim, Number> &mf,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & range) const
+ const std::pair<unsigned int, unsigned int> &range) const
{
using FEFaceIntegrator = FEFaceEvaluation<dim, -1, 0, 1, Number>;
FEFaceIntegrator eval(mf, true);
};
void
- do_faces(const MatrixFree<dim, Number> & mf,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ do_faces(const MatrixFree<dim, Number> &mf,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & range) const
+ const std::pair<unsigned int, unsigned int> &range) const
{
using FEFaceIntegrator = FEFaceEvaluation<dim, -1, 0, 1, Number>;
FEFaceIntegrator eval(mf, true);
void
vmult_pre_post_op_only(
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
data.loop(
template <int dim>
void
test(const FiniteElement<dim> &fe,
- const Quadrature<1> & quad,
- const std::string & quadrature_name)
+ const Quadrature<1> &quad,
+ const std::string &quadrature_name)
{
internal::MatrixFreeFunctions::ShapeInfo<double> shape_info;
shape_info.reinit(quad, fe, 0);
}
void
- vmult(VectorType & dst,
+ vmult(VectorType &dst,
const VectorType &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
{}
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
dst = src;
{}
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
dst = src;
void
apply_to_subrange(const unsigned int begin_range,
const unsigned int end_range,
- const Number * src_pointer_to_current_range,
- Number * dst_pointer_to_current_range) const
+ const Number *src_pointer_to_current_range,
+ Number *dst_pointer_to_current_range) const
{
AssertIndexRange(begin_range,
vec.locally_owned_elements().n_elements() + 1);
AssertIndexRange(end_range, vec.locally_owned_elements().n_elements() + 1);
- const Number * diagonal_entry = vec.begin() + begin_range;
+ const Number *diagonal_entry = vec.begin() + begin_range;
const unsigned int length = end_range - begin_range;
DEAL_II_OPENMP_SIMD_PRAGMA
template <int dim>
double
- Coefficient<dim>::value(const Point<dim> & p,
+ Coefficient<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
return value<double>(p, component);
private:
virtual void
apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const override;
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_compute_diagonal(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
- const unsigned int & dummy,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
+ const unsigned int &dummy,
const std::pair<unsigned int, unsigned int> &cell_range) const;
Table<2, VectorizedArray<number>> coefficient;
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::local_apply(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(data);
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
this->data->cell_loop(&LaplaceOperator::local_apply, this, dst, src);
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::local_compute_diagonal(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
double
- Coefficient<dim>::value(const Point<dim> & p,
+ Coefficient<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
return value<double>(p, component);
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
clear();
void
- reinit(const DoFHandler<dim> & dof_handler,
+ reinit(const DoFHandler<dim> &dof_handler,
const AffineConstraints<number> &constraints,
const unsigned int level = numbers::invalid_unsigned_int);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- Vector<double> & dst,
- const Vector<double> & src,
+ local_apply(const MatrixFree<dim, number> &data,
+ Vector<double> &dst,
+ const Vector<double> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::reinit(
- const DoFHandler<dim> & dof_handler,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<number> &constraints,
const unsigned int level)
{
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::local_apply(
- const MatrixFree<dim, number> & data,
- Vector<double> & dst,
- const Vector<double> & src,
+ const MatrixFree<dim, number> &data,
+ Vector<double> &dst,
+ const Vector<double> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(data);
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::vmult(
- Vector<double> & dst,
+ Vector<double> &dst,
const Vector<double> &src) const
{
dst = 0;
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::Tvmult(
- Vector<double> & dst,
+ Vector<double> &dst,
const Vector<double> &src) const
{
dst = 0;
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::Tvmult_add(
- Vector<double> & dst,
+ Vector<double> &dst,
const Vector<double> &src) const
{
vmult_add(dst, src);
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::vmult_add(
- Vector<double> & dst,
+ Vector<double> &dst,
const Vector<double> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src);
const double time_step);
void
- apply(LinearAlgebra::distributed::Vector<double> & dst,
+ apply(LinearAlgebra::distributed::Vector<double> &dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src)
const;
private:
- const MatrixFree<dim, double> & data;
+ const MatrixFree<dim, double> &data;
const VectorizedArray<double> delta_t_sqr;
LinearAlgebra::distributed::Vector<double> inv_mass_matrix;
void
local_apply(
- const MatrixFree<dim, double> & data,
- LinearAlgebra::distributed::Vector<double> & dst,
+ const MatrixFree<dim, double> &data,
+ LinearAlgebra::distributed::Vector<double> &dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
};
template <int dim>
void
SineGordonOperation<dim>::local_apply(
- const MatrixFree<dim> & data,
- LinearAlgebra::distributed::Vector<double> & dst,
+ 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
{
template <int dim>
void
SineGordonOperation<dim>::apply(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src) const
{
dst = 0;
const double time_step);
void
- apply(LinearAlgebra::distributed::Vector<double> & dst,
+ apply(LinearAlgebra::distributed::Vector<double> &dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src)
const;
private:
- const MatrixFree<dim, double> & data;
+ const MatrixFree<dim, double> &data;
const VectorizedArray<double> delta_t_sqr;
LinearAlgebra::distributed::Vector<double> inv_mass_matrix;
void
local_apply(
- const MatrixFree<dim, double> & data,
- LinearAlgebra::distributed::Vector<double> & dst,
+ const MatrixFree<dim, double> &data,
+ LinearAlgebra::distributed::Vector<double> &dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
};
template <int dim>
void
SineGordonOperation<dim>::local_apply(
- const MatrixFree<dim> & data,
- LinearAlgebra::distributed::Vector<double> & dst,
+ 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
{
template <int dim>
void
SineGordonOperation<dim>::apply(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src) const
{
dst = 0;
const double time_step);
void
- apply(LinearAlgebra::distributed::Vector<double> & dst,
+ apply(LinearAlgebra::distributed::Vector<double> &dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src)
const;
private:
- const MatrixFree<dim, double> & data;
+ const MatrixFree<dim, double> &data;
const VectorizedArray<double> delta_t_sqr;
LinearAlgebra::distributed::Vector<double> inv_mass_matrix;
void
local_apply(
- const MatrixFree<dim, double> & data,
- LinearAlgebra::distributed::Vector<double> & dst,
+ const MatrixFree<dim, double> &data,
+ LinearAlgebra::distributed::Vector<double> &dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
};
template <int dim>
void
SineGordonOperation<dim>::local_apply(
- const MatrixFree<dim> & data,
- LinearAlgebra::distributed::Vector<double> & dst,
+ 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
{
template <int dim>
void
SineGordonOperation<dim>::apply(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src) const
{
dst = 0;
* the inverse of the S block (Schur complement matrix).
**/
BlockSchurPreconditioner(const StokesMatrixType &S,
- const MassMatrixType & Mass,
+ const MassMatrixType &Mass,
const PreconditionerMp &Mppreconditioner,
- const PreconditionerA & Apreconditioner,
+ const PreconditionerA &Apreconditioner,
const bool do_solve_A,
const double A_block_tolerance,
const double S_block_tolerance);
* Matrix vector product with this preconditioner object.
*/
void
- vmult(LinearAlgebra::distributed::BlockVector<double> & dst,
+ vmult(LinearAlgebra::distributed::BlockVector<double> &dst,
const LinearAlgebra::distributed::BlockVector<double> &src) const;
unsigned int
* References to the various matrix object this preconditioner works on.
*/
const StokesMatrixType &stokes_matrix;
- const MassMatrixType & mass_matrix;
+ const MassMatrixType &mass_matrix;
const PreconditionerMp &mp_preconditioner;
- const PreconditionerA & a_preconditioner;
+ const PreconditionerA &a_preconditioner;
/**
* Whether to actually invert the $\tilde A$ part of the preconditioner
PreconditionerA,
PreconditionerMp>::
BlockSchurPreconditioner(const StokesMatrixType &S,
- const MassMatrixType & Mass,
+ const MassMatrixType &Mass,
const PreconditionerMp &Mppreconditioner,
- const PreconditionerA & Apreconditioner,
+ const PreconditionerA &Apreconditioner,
const bool do_solve_A,
const double A_block_tolerance,
const double S_block_tolerance)
MassMatrixType,
PreconditionerA,
PreconditionerMp>::
- vmult(LinearAlgebra::distributed::BlockVector<double> & dst,
+ vmult(LinearAlgebra::distributed::BlockVector<double> &dst,
const LinearAlgebra::distributed::BlockVector<double> &src) const
{
LinearAlgebra::distributed::BlockVector<double> utmp(src);
value(const Point<dim> &p, const unsigned int component = 0) const;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
Sinker<dim> sinker;
template <int dim>
void
Viscosity<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
template <int dim>
void
RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
double Chi = 1.0;
for (unsigned int s = 0; s < sinker.n_sinkers; ++s)
void
ExactSolution_BoundaryValues_u<dim>::vector_value(
const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
(void)p;
for (unsigned int i = 0; i < values.size(); ++i)
private:
virtual void
- apply_add(LinearAlgebra::distributed::BlockVector<number> & dst,
+ apply_add(LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src) const;
void
- local_apply(const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::BlockVector<number> & dst,
+ local_apply(const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
template <int dim, int degree_v, typename number>
void
StokesOperator<dim, degree_v, number>::local_apply(
- const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::BlockVector<number> & dst,
+ const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<number>;
FEEvaluation<dim, degree_v, degree_v + 1, dim, number> velocity(data, 0);
template <int dim, int degree_v, typename number>
void
StokesOperator<dim, degree_v, number>::apply_add(
- LinearAlgebra::distributed::BlockVector<number> & dst,
+ LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src) const
{
MatrixFreeOperators::
private:
virtual void
- apply_add(LinearAlgebra::distributed::Vector<number> & dst,
+ apply_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const;
void
- local_apply(const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_compute_diagonal(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
- const unsigned int & dummy,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
+ const unsigned int &dummy,
const std::pair<unsigned int, unsigned int> &cell_range) const;
Table<2, VectorizedArray<number>> one_over_viscosity;
template <int dim, int degree_p, typename number>
void
MassMatrixOperator<dim, degree_p, number>::local_apply(
- const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree_p, degree_p + 2, 1, number> pressure(data);
template <int dim, int degree_p, typename number>
void
MassMatrixOperator<dim, degree_p, number>::apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
MatrixFreeOperators::Base<dim,
template <int dim, int degree_p, typename number>
void
MassMatrixOperator<dim, degree_p, number>::local_compute_diagonal(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
private:
virtual void
- apply_add(LinearAlgebra::distributed::Vector<number> & dst,
+ apply_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const;
void
- local_apply(const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_compute_diagonal(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
- const unsigned int & dummy,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
+ const unsigned int &dummy,
const std::pair<unsigned int, unsigned int> &cell_range) const;
Table<2, VectorizedArray<number>> viscosity_x_2;
template <int dim, int degree_v, typename number>
void
ABlockOperator<dim, degree_v, number>::local_apply(
- const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree_v, degree_v + 1, dim, number> velocity(data);
template <int dim, int degree_v, typename number>
void
ABlockOperator<dim, degree_v, number>::apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
MatrixFreeOperators::Base<dim,
template <int dim, int degree_v, typename number>
void
ABlockOperator<dim, degree_v, number>::local_compute_diagonal(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
mg_transfer.initialize_constraints(mg_constrained_dofs);
mg_transfer.build(dof_handler_u);
- LevelMatrixType & coarse_matrix = mg_matrices[0];
+ LevelMatrixType &coarse_matrix = mg_matrices[0];
SolverControl coarse_solver_control(1000, 1e-12, false, false);
SolverCG<vector_t> coarse_solver(coarse_solver_control);
: data(data_in){};
void
- local_apply(const MatrixFree<dim, Number> & data,
- Vector<Number> & dst,
- const Vector<Number> & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ Vector<Number> &dst,
+ const Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
helmholtz_operator_no_template<dim>(data, dst, src, cell_range);
TestIntegrator(){};
void
- cell(MeshWorker::DoFInfo<dim, spacedim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim, spacedim> &dinfo,
typename MeshWorker::IntegrationInfo<dim, spacedim> &info) const {};
void
- boundary(MeshWorker::DoFInfo<dim, spacedim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim, spacedim> &dinfo,
typename MeshWorker::IntegrationInfo<dim, spacedim> &info) const {};
void
- face(MeshWorker::DoFInfo<dim, spacedim> & dinfo1,
- MeshWorker::DoFInfo<dim, spacedim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim, spacedim> &dinfo1,
+ MeshWorker::DoFInfo<dim, spacedim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim, spacedim> &info1,
typename MeshWorker::IntegrationInfo<dim, spacedim> &info2) const {};
};
<< std::endl;
};
- auto face_worker = [](const Iterator & cell,
+ auto face_worker = [](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
deallog << "Face worker on : " << cell << ", Neighbor cell : " << ncell
<< ", Face : " << f << ", Neighbor Face : " << nf
<< ", Subface: " << sf << ", Neighbor Subface: " << nsf
<< std::endl;
};
- auto face_worker = [](const Iterator & cell,
+ auto face_worker = [](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
deallog << "Face worker on : " << cell << ", Neighbor cell : " << ncell
<< ", Face : " << f << ", Neighbor Face : " << nf
<< ", Subface: " << sf << ", Neighbor Subface: " << nsf
c.vectors[0][0] += w;
};
- auto boundary_worker = [](const Iterator & cell,
+ auto boundary_worker = [](const Iterator &cell,
const unsigned int &f,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f);
const auto &JxW = s.get_JxW_values();
for (auto w : JxW)
c.vectors[0][1] += w;
};
- auto face_worker = [](const Iterator & cell,
+ auto face_worker = [](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f, sf);
const auto &nfev = s.reinit_neighbor(ncell, nf, nsf);
c.vectors[0][0] += w;
};
- auto boundary_worker = [](const Iterator & cell,
+ auto boundary_worker = [](const Iterator &cell,
const unsigned int &f,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f);
const auto &JxW = s.get_JxW_values();
for (auto w : JxW)
c.vectors[0][1] += w;
};
- auto face_worker = [](const Iterator & cell,
+ auto face_worker = [](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f, sf);
const auto &nfev = s.reinit_neighbor(ncell, nf, nsf);
c.vectors[0][0] += w;
};
- auto boundary_worker = [](const Iterator & cell,
+ auto boundary_worker = [](const Iterator &cell,
const unsigned int &f,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f);
const auto &JxW = s.get_JxW_values();
for (auto w : JxW)
c.vectors[0][1] += w;
};
- auto face_worker = [](const Iterator & cell,
+ auto face_worker = [](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f, sf);
const auto &nfev = s.reinit_neighbor(ncell, nf, nsf);
CopyData copy(1);
auto cell_worker = [](const CellIteratorType &cell,
- ScratchData & scratch_data,
- CopyData & copy_data) {
+ ScratchData &scratch_data,
+ CopyData ©_data) {
const auto &fe_values = scratch_data.reinit(cell);
for (unsigned int q_point = 0; q_point < fe_values.n_quadrature_points;
auto boundary_worker = [](const CellIteratorType &cell,
const unsigned int face,
- ScratchData & scratch_data,
- CopyData & copy_data) {
+ ScratchData &scratch_data,
+ CopyData ©_data) {
const auto &fe_face_values = scratch_data.reinit(cell, face);
for (unsigned int q_point = 0;
<< std::endl;
};
- auto face_worker = [](const Iterator & cell,
+ auto face_worker = [](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
deallog << "Face worker on : " << cell << ", Neighbor cell : " << ncell
<< ", Face : " << f << ", Neighbor Face : " << nf
<< ", Subface: " << sf << ", Neighbor Subface: " << nsf
c.vectors[0][0] += w * i;
};
- auto boundary_worker = [&i](const Iterator & cell,
+ auto boundary_worker = [&i](const Iterator &cell,
const unsigned int &f,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f);
const auto &JxW = s.get_JxW_values();
for (auto w : JxW)
c.vectors[0][1] += w * i;
};
- auto face_worker = [&i](const Iterator & cell,
+ auto face_worker = [&i](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f, sf);
const auto &nfev = s.reinit_neighbor(ncell, nf, nsf);
c.matrices[0][0][0] += w * i;
};
- auto boundary_worker = [&i](const Iterator & cell,
+ auto boundary_worker = [&i](const Iterator &cell,
const unsigned int &f,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f);
const auto &JxW = s.get_JxW_values();
for (auto w : JxW)
c.matrices[0][0][1] += w * i;
};
- auto face_worker = [&i](const Iterator & cell,
+ auto face_worker = [&i](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f, sf);
const auto &nfev = s.reinit_neighbor(ncell, nf, nsf);
<< std::endl;
};
- auto face_worker = [](const Iterator & cell,
+ auto face_worker = [](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
deallog << "Face worker on : " << cell << ", Neighbor cell : " << ncell
<< ", Face : " << f << ", Neighbor Face : " << nf
<< ", Subface: " << sf << ", Neighbor Subface: " << nsf
<< std::endl;
};
- auto face_worker = [](const Iterator & cell,
+ auto face_worker = [](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
deallog << "Face worker on : " << cell << ", Neighbor cell : " << ncell
<< ", Face : " << f << ", Neighbor Face : " << nf
<< ", Subface: " << sf << ", Neighbor Subface: " << nsf
c.vectors[0][0] += w;
};
- auto boundary_worker = [](const Iterator & cell,
+ auto boundary_worker = [](const Iterator &cell,
const unsigned int &f,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f);
const auto &JxW = s.get_JxW_values();
for (auto w : JxW)
c.vectors[0][1] += w;
};
- auto face_worker = [](const Iterator & cell,
+ auto face_worker = [](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f, sf);
const auto &nfev = s.reinit_neighbor(ncell, nf, nsf);
c.vectors[0][0] += w;
};
- auto boundary_worker = [](const Iterator & cell,
+ auto boundary_worker = [](const Iterator &cell,
const unsigned int &f,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f);
const auto &JxW = s.get_JxW_values();
for (auto w : JxW)
c.vectors[0][1] += w;
};
- auto face_worker = [](const Iterator & cell,
+ auto face_worker = [](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f, sf);
const auto &nfev = s.reinit_neighbor(ncell, nf, nsf);
}
};
- auto boundary_worker = [gamma, &boundary_function](const Iterator & cell,
+ auto boundary_worker = [gamma, &boundary_function](const Iterator &cell,
const unsigned int &f,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f);
const auto &JxW = s.get_JxW_values();
const auto &p = s.get_quadrature_points();
}
};
- auto face_worker = [gamma](const Iterator & cell,
+ auto face_worker = [gamma](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f, sf);
const auto &JxW = s.get_JxW_values();
const auto &nfev = s.reinit_neighbor(ncell, nf, nsf);
}
};
- auto boundary_worker = [gamma, &boundary_function](const Iterator & cell,
+ auto boundary_worker = [gamma, &boundary_function](const Iterator &cell,
const unsigned int &f,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f);
const auto &JxW = s.get_JxW_values();
const auto &p = s.get_quadrature_points();
}
};
- auto face_worker = [gamma](const Iterator & cell,
+ auto face_worker = [gamma](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, ncell, f, sf);
const auto &JxW = s.get_JxW_values();
const auto &nfev = s.reinit_neighbor(cell, ncell, nf, nsf);
auto cell_integrator = [&H1_norm, &solution, &scalar](const Iterator &cell,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell);
const auto &JxW = s.get_JxW_values();
FEValuesExtractors::Scalar scalar(0);
auto cell_worker = [&rhs_function, &solution, &scalar](const Iterator &cell,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell);
const auto &JxW = s.get_JxW_values();
const auto &p = s.get_quadrature_points();
FEValuesExtractors::Scalar scalar(0);
auto cell_worker = [&rhs_function, &solution, &scalar](const Iterator &cell,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell);
const auto &JxW = s.get_JxW_values();
const auto &p = s.get_quadrature_points();
FEValuesExtractors::Scalar scalar(0);
auto cell_worker = [&rhs_function, &solution, &scalar](const Iterator &cell,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell);
const auto &JxW = s.get_JxW_values();
const auto &p = s.get_quadrature_points();
}
};
- auto boundary_worker = [gamma, &boundary_function](const Iterator & cell,
+ auto boundary_worker = [gamma, &boundary_function](const Iterator &cell,
const unsigned int &f,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f);
const auto &JxW = s.get_JxW_values();
const auto &p = s.get_quadrature_points();
}
};
- auto face_worker = [gamma](const Iterator & cell,
+ auto face_worker = [gamma](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData & s,
- CopyData & c) {
+ ScratchData &s,
+ CopyData &c) {
const auto &fev = s.reinit(cell, f, sf, ncell, nf, nsf);
const auto &JxW = s.get_JxW_values();
template <int dim>
struct ScratchData
{
- ScratchData(const Mapping<dim> & mapping,
+ ScratchData(const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
const unsigned int quadrature_degree)
: fe_values(mapping,
{
using Iterator = decltype(dof_handler.begin_active());
- auto cell_worker = [](const Iterator & cell,
+ auto cell_worker = [](const Iterator &cell,
ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
const unsigned int dofs_per_cell =
scratch_data.fe_values.get_fe().dofs_per_cell;
const unsigned int n_q_points =
}
};
- auto boundary_worker = [](const Iterator & cell,
+ auto boundary_worker = [](const Iterator &cell,
const unsigned int &face_no,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
const unsigned int dofs_per_cell =
scratch_data.fe_values.get_fe().dofs_per_cell;
const unsigned int n_face_q_points =
template <class IteratorType>
void
assemble_cell(const IteratorType &cell,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data);
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data);
void
assemble_system_and_multigrid();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
(void)component;
template <class IteratorType>
void
LaplaceProblem<dim>::assemble_cell(const IteratorType &cell,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data)
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data)
{
const unsigned int level = cell->level();
copy_data.level = level;
auto cell_worker_active =
[&](const decltype(mg_dof_handler.begin_active()) &cell,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
this->assemble_cell(cell, scratch_data, copy_data);
};
auto cell_worker_mg = [&](const decltype(mg_dof_handler.begin_mg()) &cell,
ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
this->assemble_cell(cell, scratch_data, copy_data);
};
std::vector<char>
pack_function(
const typename parallel::distributed::Triangulation<dim, dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status)
{
static int some_number = 0;
void
unpack_function(
const typename parallel::distributed::Triangulation<dim, dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator> &data_range)
{
std::vector<char>
pack_function(
const typename parallel::distributed::Triangulation<dim, dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status)
{
static unsigned int some_number = 1;
void
unpack_function(
const typename parallel::distributed::Triangulation<dim, dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator> &data_range)
{
template <int dim, int spacedim>
void
write_vtk(const parallel::distributed::Triangulation<dim, spacedim> &tria,
- const char * filename)
+ const char *filename)
{
AssertThrow(tria.are_vertices_communicated_to_p4est(),
ExcMessage("To use this function the flag "
void
calculate_flux_terms(
const TriaActiveIterator<DoFCellAccessor<dim, dim, false>> ¤t_cell,
- FEFaceValues<dim> & current_face_values,
+ FEFaceValues<dim> ¤t_face_values,
const TriaIterator<DoFCellAccessor<dim, dim, false>> &neighbor_cell,
- FEFaceValues<dim> & neighbor_face_values,
+ FEFaceValues<dim> &neighbor_face_values,
FullMatrix<double> ¤t_to_current_flux,
FullMatrix<double> ¤t_to_neighbor_flux,
FullMatrix<double> &neighbor_to_current_flux,
void
AdvectionProblem<dim>::calculate_flux_terms(
const TriaActiveIterator<DoFCellAccessor<dim, dim, false>> ¤t_cell,
- FEFaceValues<dim> & current_face_values,
+ FEFaceValues<dim> ¤t_face_values,
const TriaIterator<DoFCellAccessor<dim, dim, false>> &neighbor_cell,
- FEFaceValues<dim> & neighbor_face_values,
+ FEFaceValues<dim> &neighbor_face_values,
FullMatrix<double> ¤t_to_current_flux,
FullMatrix<double> ¤t_to_neighbor_flux,
FullMatrix<double> &neighbor_to_current_flux,
}
}
else // boundary face: skip for the purposes of this test
- {}
+ {
+ }
}
}
}
void
check(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
- const std::string & name)
+ const std::string &name)
{
if (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0)
deallog << "Checking " << name << " in " << dim << "d:" << std::endl;
void
check(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
- const std::string & name)
+ const std::string &name)
{
if (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0)
deallog << "Checking " << name << " in " << dim << "d:" << std::endl;
void
check(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
- const std::string & name)
+ const std::string &name)
{
if (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0)
deallog << "Checking " << name << " in " << dim << "d:" << std::endl;
void
check(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
- const std::string & name)
+ const std::string &name)
{
if (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0)
deallog << "Checking " << name << " in " << dim << "d:" << std::endl;
void
check(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
- const std::string & name)
+ const std::string &name)
{
if (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0)
deallog << "Checking " << name << " in " << dim << "d:" << std::endl;
void
check(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
- const std::string & name)
+ const std::string &name)
{
if (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0)
deallog << "Checking " << name << " in " << dim << "d:" << std::endl;
#include "../tests.h"
-//#define DEBUG_OUTPUT_VTK
+// #define DEBUG_OUTPUT_VTK
template <int dim>
class TestFunction : public Function<dim>
template <int dim>
DoFHandler<dim> *
make_dof_handler(const parallel::distributed::Triangulation<dim> &tria,
- const FiniteElement<dim> & fe)
+ const FiniteElement<dim> &fe)
{
DoFHandler<dim> *dof_handler = new DoFHandler<dim>(tria);
dof_handler->distribute_dofs(fe);
// output some indicators for a given vector
template <unsigned int dim, typename VectorType>
void
-output_vector(const VectorType & v,
- const std::string & output_name,
+output_vector(const VectorType &v,
+ const std::string &output_name,
const DoFHandler<dim> &dof_handler)
{
DataOut<dim> data_out;
parallel::distributed::Triangulation<dim> triangulation;
const MappingQ<dim> mapping;
- const FiniteElement<dim> & fe;
+ const FiniteElement<dim> &fe;
DoFHandler<dim> dof_handler;
IndexSet locally_relevant_set;
#include "../tests.h"
-//#define DISTRIBUTED
+// #define DISTRIBUTED
template <int dim>
void
template <int dim>
void
setup(DoFHandler<dim> &dh,
- FE_Q<dim> & fe,
+ FE_Q<dim> &fe,
LA::MPI::Vector &vec,
LA::MPI::Vector &lr_vec)
{
template <int dim>
void
-output(DoFHandler<dim> & dh,
- LA::MPI::Vector & v,
+output(DoFHandler<dim> &dh,
+ LA::MPI::Vector &v,
unsigned int loop,
const std::string filename_)
{
void
face(MeshWorker::DoFInfo<dim> &dinfo1,
MeshWorker::DoFInfo<dim> &dinfo2,
- CellInfo & info1,
- CellInfo & info2) const;
+ CellInfo &info1,
+ CellInfo &info2) const;
};
template <int dim>
void
face(MeshWorker::DoFInfo<dim> &dinfo1,
MeshWorker::DoFInfo<dim> &dinfo2,
- CellInfo & info1,
- CellInfo & info2) const;
+ CellInfo &info1,
+ CellInfo &info2) const;
};
template <int dim>
void
face(MeshWorker::DoFInfo<dim> &dinfo1,
MeshWorker::DoFInfo<dim> &dinfo2,
- CellInfo & info1,
- CellInfo & info2) const;
+ CellInfo &info1,
+ CellInfo &info2) const;
};
template <int dim>
void
face(MeshWorker::DoFInfo<dim> &dinfo1,
MeshWorker::DoFInfo<dim> &dinfo2,
- CellInfo & info1,
- CellInfo & info2) const;
+ CellInfo &info1,
+ CellInfo &info2) const;
};
template <int dim>
void
face(MeshWorker::DoFInfo<dim> &dinfo1,
MeshWorker::DoFInfo<dim> &dinfo2,
- CellInfo & info1,
- CellInfo & info2) const;
+ CellInfo &info1,
+ CellInfo &info2) const;
};
template <int dim>
void
face(MeshWorker::DoFInfo<dim> &dinfo1,
MeshWorker::DoFInfo<dim> &dinfo2,
- CellInfo & info1,
- CellInfo & info2) const;
+ CellInfo &info1,
+ CellInfo &info2) const;
bool cells;
bool faces;
void
get_point_value(const Point<dim> point,
const int proc,
- Vector<double> & value) const;
+ Vector<double> &value) const;
void
check_periodicity(const unsigned int cycle) const;
void
template <int dim>
double
- BoundaryValues<dim>::value(const Point<dim> & p,
+ BoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
template <int dim>
void
BoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = BoundaryValues<dim>::value(p, c);
template <int dim>
void
RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = RightHandSide<dim>::value(p, c);
class InverseMatrix : public Preconditioner
{
public:
- InverseMatrix(const Matrix & m,
+ InverseMatrix(const Matrix &m,
const Preconditioner &preconditioner,
- const IndexSet & locally_owned,
+ const IndexSet &locally_owned,
const MPI_Comm mpi_communicator);
void
- vmult(TrilinosWrappers::MPI::Vector & dst,
+ vmult(TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const;
private:
template <class Matrix, class Preconditioner>
InverseMatrix<Matrix, Preconditioner>::InverseMatrix(
- const Matrix & m,
+ const Matrix &m,
const Preconditioner &preconditioner,
- const IndexSet & locally_owned,
+ const IndexSet &locally_owned,
const MPI_Comm mpi_communicator)
: matrix(&m)
, preconditioner(&preconditioner)
template <class Matrix, class Preconditioner>
void
InverseMatrix<Matrix, Preconditioner>::vmult(
- TrilinosWrappers::MPI::Vector & dst,
+ TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const
{
SolverControl solver_control(src.size(),
public:
SchurComplement(const TrilinosWrappers::BlockSparseMatrix &system_matrix,
const InverseMatrix<TrilinosWrappers::SparseMatrix,
- Preconditioner> & A_inverse,
- const IndexSet & owned_pres,
- const IndexSet & relevant_pres,
+ Preconditioner> &A_inverse,
+ const IndexSet &owned_pres,
+ const IndexSet &relevant_pres,
const MPI_Comm mpi_communicator);
void
- vmult(TrilinosWrappers::MPI::Vector & dst,
+ vmult(TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const;
private:
SchurComplement<Preconditioner>::SchurComplement(
const TrilinosWrappers::BlockSparseMatrix &system_matrix,
const InverseMatrix<TrilinosWrappers::SparseMatrix, Preconditioner>
- & A_inverse,
+ &A_inverse,
const IndexSet &owned_vel,
const IndexSet &relevant_vel,
const MPI_Comm mpi_communicator)
template <class Preconditioner>
void
SchurComplement<Preconditioner>::vmult(
- TrilinosWrappers::MPI::Vector & dst,
+ TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const
{
system_matrix->block(0, 1).vmult(tmp1, src);
void
StokesProblem<dim>::get_point_value(const Point<dim> point,
const int proc,
- Vector<double> & value) const
+ Vector<double> &value) const
{
typename DoFHandler<dim>::active_cell_iterator cell =
GridTools::find_active_cell_around_point(dof_handler, point);
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
template <int dim>
void
TemperatureInitialValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = TemperatureInitialValues<dim>::value(p, c);
return cell;
},
- [](const Triangulation<dim> & t,
+ [](const Triangulation<dim> &t,
const typename Triangulation<dim>::cell_iterator &old_cell) ->
typename Triangulation<dim>::cell_iterator {
if (old_cell != t.end())
template <int dim>
void
TemperatureInitialValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = TemperatureInitialValues<dim>::value(p, c);
return cell;
},
- [](const Triangulation<dim> & t,
+ [](const Triangulation<dim> &t,
const typename Triangulation<dim>::cell_iterator &old_cell) ->
typename Triangulation<dim>::cell_iterator {
if (old_cell != t.end())
std::vector<char>
pack_function(
const typename parallel::distributed::Triangulation<dim, dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status)
{
static unsigned int some_number = 1;
void
unpack_function(
const typename parallel::distributed::Triangulation<dim, dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator> &data_range)
{
std::vector<char>
pack_function(
const typename parallel::distributed::Triangulation<dim, dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status)
{
static unsigned int some_number = 1;
void
unpack_function(
const typename parallel::distributed::Triangulation<dim, dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator> &data_range)
{
void
get_point_value(const Point<dim> point,
const int proc,
- Vector<double> & value) const;
+ Vector<double> &value) const;
void
check_periodicity(const unsigned int cycle) const;
void
template <int dim>
double
- BoundaryValues<dim>::value(const Point<dim> & p,
+ BoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
template <int dim>
void
BoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = BoundaryValues<dim>::value(p, c);
template <int dim>
void
RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = RightHandSide<dim>::value(p, c);
class InverseMatrix : public Preconditioner
{
public:
- InverseMatrix(const Matrix & m,
+ InverseMatrix(const Matrix &m,
const Preconditioner &preconditioner,
- const IndexSet & locally_owned,
+ const IndexSet &locally_owned,
const MPI_Comm mpi_communicator);
void
- vmult(TrilinosWrappers::MPI::Vector & dst,
+ vmult(TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const;
private:
template <class Matrix, class Preconditioner>
InverseMatrix<Matrix, Preconditioner>::InverseMatrix(
- const Matrix & m,
+ const Matrix &m,
const Preconditioner &preconditioner,
- const IndexSet & locally_owned,
+ const IndexSet &locally_owned,
const MPI_Comm mpi_communicator)
: matrix(&m)
, preconditioner(&preconditioner)
template <class Matrix, class Preconditioner>
void
InverseMatrix<Matrix, Preconditioner>::vmult(
- TrilinosWrappers::MPI::Vector & dst,
+ TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const
{
SolverControl solver_control(src.size(),
public:
SchurComplement(const TrilinosWrappers::BlockSparseMatrix &system_matrix,
const InverseMatrix<TrilinosWrappers::SparseMatrix,
- Preconditioner> & A_inverse,
- const IndexSet & owned_pres,
- const IndexSet & relevant_pres,
+ Preconditioner> &A_inverse,
+ const IndexSet &owned_pres,
+ const IndexSet &relevant_pres,
const MPI_Comm mpi_communicator);
void
- vmult(TrilinosWrappers::MPI::Vector & dst,
+ vmult(TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const;
private:
SchurComplement<Preconditioner>::SchurComplement(
const TrilinosWrappers::BlockSparseMatrix &system_matrix,
const InverseMatrix<TrilinosWrappers::SparseMatrix, Preconditioner>
- & A_inverse,
+ &A_inverse,
const IndexSet &owned_vel,
const IndexSet &relevant_vel,
const MPI_Comm mpi_communicator)
template <class Preconditioner>
void
SchurComplement<Preconditioner>::vmult(
- TrilinosWrappers::MPI::Vector & dst,
+ TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const
{
system_matrix->block(0, 1).vmult(tmp1, src);
void
StokesProblem<dim>::get_point_value(const Point<dim> point,
const int proc,
- Vector<double> & value) const
+ Vector<double> &value) const
{
typename DoFHandler<dim>::active_cell_iterator cell =
GridTools::find_active_cell_around_point(dof_handler, point);
void
get_point_value(const Point<dim> point,
const int proc,
- Vector<double> & value) const;
+ Vector<double> &value) const;
void
check_periodicity() const;
void
class InverseMatrix : public Preconditioner
{
public:
- InverseMatrix(const Matrix & m,
+ InverseMatrix(const Matrix &m,
const Preconditioner &preconditioner,
- const IndexSet & locally_owned,
+ const IndexSet &locally_owned,
const MPI_Comm mpi_communicator);
void
- vmult(TrilinosWrappers::MPI::Vector & dst,
+ vmult(TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const;
private:
template <class Matrix, class Preconditioner>
InverseMatrix<Matrix, Preconditioner>::InverseMatrix(
- const Matrix & m,
+ const Matrix &m,
const Preconditioner &preconditioner,
- const IndexSet & locally_owned,
+ const IndexSet &locally_owned,
const MPI_Comm mpi_communicator)
: matrix(&m)
, preconditioner(&preconditioner)
template <class Matrix, class Preconditioner>
void
InverseMatrix<Matrix, Preconditioner>::vmult(
- TrilinosWrappers::MPI::Vector & dst,
+ TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const
{
SolverControl solver_control(src.size(),
public:
SchurComplement(const TrilinosWrappers::BlockSparseMatrix &system_matrix,
const InverseMatrix<TrilinosWrappers::SparseMatrix,
- Preconditioner> & A_inverse,
- const IndexSet & owned_pres,
+ Preconditioner> &A_inverse,
+ const IndexSet &owned_pres,
const MPI_Comm mpi_communicator);
void
- vmult(TrilinosWrappers::MPI::Vector & dst,
+ vmult(TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const;
private:
SchurComplement<Preconditioner>::SchurComplement(
const TrilinosWrappers::BlockSparseMatrix &system_matrix,
const InverseMatrix<TrilinosWrappers::SparseMatrix, Preconditioner>
- & A_inverse,
+ &A_inverse,
const IndexSet &owned_vel,
const MPI_Comm mpi_communicator)
: system_matrix(&system_matrix)
template <class Preconditioner>
void
SchurComplement<Preconditioner>::vmult(
- TrilinosWrappers::MPI::Vector & dst,
+ TrilinosWrappers::MPI::Vector &dst,
const TrilinosWrappers::MPI::Vector &src) const
{
system_matrix->block(0, 1).vmult(tmp1, src);
void
StokesProblem<dim>::get_point_value(const Point<dim> point,
const int proc,
- Vector<double> & value) const
+ Vector<double> &value) const
{
const typename DoFHandler<dim>::active_cell_iterator cell =
GridTools::find_active_cell_around_point(dof_handler, point);
int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
- Point<3>(+1., -1., -3.),
- Point<3>(-1., +1., -3.),
- Point<3>(+1., +1., -3.),
- Point<3>(-1., -1., -1.),
- Point<3>(+1., -1., -1.),
- Point<3>(-1., +1., -1.),
- Point<3>(+1., +1., -1.),
- Point<3>(-1., -1., +1.),
- Point<3>(+1., -1., +1.),
- Point<3>(-1., +1., +1.),
- Point<3>(+1., +1., +1.),
- Point<3>(-1., -1., +3.),
- Point<3>(+1., -1., +3.),
- Point<3>(-1., +1., +3.),
- Point<3>(+1., +1., +3.)};
+ Point<3>(+1., -1., -3.),
+ Point<3>(-1., +1., -3.),
+ Point<3>(+1., +1., -3.),
+ Point<3>(-1., -1., -1.),
+ Point<3>(+1., -1., -1.),
+ Point<3>(-1., +1., -1.),
+ Point<3>(+1., +1., -1.),
+ Point<3>(-1., -1., +1.),
+ Point<3>(+1., -1., +1.),
+ Point<3>(-1., +1., +1.),
+ Point<3>(+1., +1., +1.),
+ Point<3>(-1., -1., +3.),
+ Point<3>(+1., -1., +3.),
+ Point<3>(-1., +1., +3.),
+ Point<3>(+1., +1., +3.)};
std::vector<Point<3>> vertices(&vertices_1[0], &vertices_1[16]);
std::vector<CellData<3>> cells(2, CellData<3>());
#include "../tests.h"
-//#include <mpi.h>
+// #include <mpi.h>
void
#include "../tests.h"
-//#include <mpi.h>
+// #include <mpi.h>
void
#include "../tests.h"
-//#include <mpi.h>
+// #include <mpi.h>
template <class v>
void
template <int dim>
void
FluxBoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & bdry_flux) const
+ Vector<double> &bdry_flux) const
{
Assert(bdry_flux.size() == dim,
ExcDimensionMismatch(bdry_flux.size(), dim));
// document bug in parallel::distributed::GridRefinement
// ::refine_and_coarsen_fixed_number() and fixed_fraction() with one CPU with
// 0 cells:
-//#0 0x00007ffff67297e2 in dealii::(anonymous namespace)::min_element<float> (
+// #0 0x00007ffff67297e2 in dealii::(anonymous namespace)::min_element<float> (
// criteria=...)
// at /w/heister/deal-trunk/deal.II/source/distributed/grid_refinement.cc:57
-//#1 0x00007ffff6727672 in dealii::(anonymous
+// #1 0x00007ffff6727672 in dealii::(anonymous
// namespace)::compute_global_min_and_max_at_root<float> (criteria=...,
// mpi_communicator=0x6fc860)
// at /w/heister/deal-trunk/deal.II/source/distributed/grid_refinement.cc:82
-//#2 0x00007ffff672b4ef in
+// #2 0x00007ffff672b4ef in
// dealii::parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number<2,
// dealii::Vector<float>, 2>
#include <deal.II/lac/vector.h>
#include "../tests.h"
-//#include <mpi.h>
+// #include <mpi.h>
template <int dim>
void
template <int dim>
void
verify(parallel::distributed::Triangulation<dim> &tr,
- const Vector<float> & criteria,
+ const Vector<float> &criteria,
const float refinement_fraction,
const float coarsening_fraction)
{
if (myid == i)
MPI_Send(&renumbering[0],
renumbering.size(),
- Utilities::MPI::mpi_type_id_for_type<decltype(
- complete_renumbering[0])>,
+ Utilities::MPI::mpi_type_id_for_type<
+ decltype(complete_renumbering[0])>,
0,
i,
MPI_COMM_WORLD);
else if (myid == 0)
MPI_Recv(&complete_renumbering[offset],
dofs_per_proc[i].n_elements(),
- Utilities::MPI::mpi_type_id_for_type<decltype(
- complete_renumbering[0])>,
+ Utilities::MPI::mpi_type_id_for_type<
+ decltype(complete_renumbering[0])>,
i,
i,
MPI_COMM_WORLD,
if (myid == i)
MPI_Send(&renumbering[0],
renumbering.size(),
- Utilities::MPI::mpi_type_id_for_type<decltype(
- complete_renumbering[0])>,
+ Utilities::MPI::mpi_type_id_for_type<
+ decltype(complete_renumbering[0])>,
0,
i,
MPI_COMM_WORLD);
else if (myid == 0)
MPI_Recv(&complete_renumbering[offset],
locally_owned_dofs_per_processor[i].n_elements(),
- Utilities::MPI::mpi_type_id_for_type<decltype(
- complete_renumbering[0])>,
+ Utilities::MPI::mpi_type_id_for_type<
+ decltype(complete_renumbering[0])>,
i,
i,
MPI_COMM_WORLD,
std::vector<char>
pack_function(
const typename parallel::distributed::Triangulation<dim, dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status)
{
static int some_number = cell->index();
void
unpack_function(
const typename parallel::distributed::Triangulation<dim, dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status,
const boost::iterator_range<std::vector<char>::const_iterator> &data_range)
{
#include "../tests.h"
-//#include <mpi.h>
+// #include <mpi.h>
void
template <typename DH>
void
-initialize_indexsets(IndexSet & locally_owned_dofs,
- IndexSet & locally_relevant_dofs,
+initialize_indexsets(IndexSet &locally_owned_dofs,
+ IndexSet &locally_relevant_dofs,
std::vector<IndexSet> &locally_owned_partitioning,
std::vector<IndexSet> &locally_relevant_partitioning,
- const DH & dof_handler,
+ const DH &dof_handler,
const std::vector<unsigned int> &block_component,
const unsigned int this_mpi_process)
{
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().tensor_degree();
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
RHSIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
- Vector<double> & local_vector = dinfo.vector(0).block(0);
+ Vector<double> &local_vector = dinfo.vector(0).block(0);
std::vector<double> boundary_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), boundary_values);
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
- Estimator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+ Estimator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
Estimator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
- Estimator<dim>::face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ Estimator<dim>::face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
- const std::vector<double> & uh1 = info1.values[0][0];
- const std::vector<double> & uh2 = info2.values[0][0];
+ const FEValuesBase<dim> &fe = info1.fe_values();
+ const std::vector<double> &uh1 = info1.values[0][0];
+ const std::vector<double> &uh2 = info2.values[0][0];
const std::vector<Tensor<1, dim>> &Duh1 = info1.gradients[0][0];
const std::vector<Tensor<1, dim>> &Duh2 = info2.gradients[0][0];
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
ErrorIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
- const FEValuesBase<dim> & fe = info.fe_values();
+ const FEValuesBase<dim> &fe = info.fe_values();
std::vector<Tensor<1, dim>> exact_gradients(fe.n_quadrature_points);
std::vector<double> exact_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), exact_values);
const std::vector<Tensor<1, dim>> &Duh = info.gradients[0][0];
- const std::vector<double> & uh = info.values[0][0];
+ const std::vector<double> &uh = info.values[0][0];
for (unsigned k = 0; k < fe.n_quadrature_points; ++k)
{
template <int dim>
void
ErrorIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
ErrorIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
+ const FEValuesBase<dim> &fe = info1.fe_values();
const std::vector<double> &uh1 = info1.values[0][0];
const std::vector<double> &uh2 = info2.values[0][0];
parallel::distributed::Triangulation<dim> triangulation;
const MappingQ<dim> mapping;
- const FiniteElement<dim> & fe;
+ const FiniteElement<dim> &fe;
DoFHandler<dim> dof_handler;
IndexSet locally_relevant_set;
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().tensor_degree();
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
RHSIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
- Vector<double> & local_vector = dinfo.vector(0).block(0);
+ Vector<double> &local_vector = dinfo.vector(0).block(0);
std::vector<double> boundary_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), boundary_values);
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
- Estimator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+ Estimator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
Estimator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
- Estimator<dim>::face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ Estimator<dim>::face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
- const std::vector<double> & uh1 = info1.values[0][0];
- const std::vector<double> & uh2 = info2.values[0][0];
+ const FEValuesBase<dim> &fe = info1.fe_values();
+ const std::vector<double> &uh1 = info1.values[0][0];
+ const std::vector<double> &uh2 = info2.values[0][0];
const std::vector<Tensor<1, dim>> &Duh1 = info1.gradients[0][0];
const std::vector<Tensor<1, dim>> &Duh2 = info2.gradients[0][0];
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
ErrorIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
- const FEValuesBase<dim> & fe = info.fe_values();
+ const FEValuesBase<dim> &fe = info.fe_values();
std::vector<Tensor<1, dim>> exact_gradients(fe.n_quadrature_points);
std::vector<double> exact_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), exact_values);
const std::vector<Tensor<1, dim>> &Duh = info.gradients[0][0];
- const std::vector<double> & uh = info.values[0][0];
+ const std::vector<double> &uh = info.values[0][0];
for (unsigned k = 0; k < fe.n_quadrature_points; ++k)
{
template <int dim>
void
ErrorIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
ErrorIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
+ const FEValuesBase<dim> &fe = info1.fe_values();
const std::vector<double> &uh1 = info1.values[0][0];
const std::vector<double> &uh2 = info2.values[0][0];
parallel::distributed::Triangulation<dim> triangulation;
const MappingQ<dim> mapping;
- const FiniteElement<dim> & fe;
+ const FiniteElement<dim> &fe;
DoFHandler<dim> dof_handler;
IndexSet locally_relevant_set;
template <typename MeshType, typename Number>
void
initialize_dof_vector(LinearAlgebra::distributed::Vector<Number> &vec,
- const MeshType & dof_handler,
+ const MeshType &dof_handler,
const unsigned int level)
{
IndexSet locally_relevant_dofs;
void
test_transfer_operator(
const MGTwoLevelTransfer<dim, LinearAlgebra::distributed::Vector<Number>>
- & transfer,
- const MeshType & dof_handler_fine,
- const MeshType & dof_handler_coarse,
+ &transfer,
+ const MeshType &dof_handler_fine,
+ const MeshType &dof_handler_coarse,
const unsigned int mg_level_fine = numbers::invalid_unsigned_int,
const unsigned int mg_level_coarse = numbers::invalid_unsigned_int)
{
test_non_nested_transfer(
const MGTwoLevelTransferNonNested<dim,
LinearAlgebra::distributed::Vector<Number>>
- & transfer,
- const MeshType & dof_handler_fine,
- const MeshType & dof_handler_coarse,
+ &transfer,
+ const MeshType &dof_handler_fine,
+ const MeshType &dof_handler_coarse,
const Function<dim, Number> &function =
Functions::ZeroFunction<dim, Number>(),
const unsigned int mg_level_fine = numbers::invalid_unsigned_int,
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
+ 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)
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_apply_face(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval_neighbor(data, false);
void
local_apply_boundary(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
for (unsigned int face = face_range.first; face < face_range.second; ++face)
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
void
local_diagonal_face(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
void
local_diagonal_boundary(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
virtual void
operator()(const unsigned int,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-7, false, false);
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
+ 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)
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
if (!src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_apply_face(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval_neighbor(data, false);
void
local_apply_boundary(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
for (unsigned int face = face_range.first; face < face_range.second; ++face)
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
void
local_diagonal_face(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
void
local_diagonal_boundary(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
virtual void
operator()(const unsigned int,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10, false, false);
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
+ 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)
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
if (!src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_apply_face(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval_neighbor(data, false);
void
local_apply_boundary(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
for (unsigned int face = face_range.first; face < face_range.second; ++face)
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10, false, false);
using FECellIntegrator = FEEvaluation<dim, -1, 0, 1, number>;
void
- reinit(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
- const Quadrature<dim> & quad,
+ reinit(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
+ const Quadrature<dim> &quad,
const AffineConstraints<number> &constraints,
const unsigned int mg_level = numbers::invalid_unsigned_int)
{
void
do_cell_integral_global(FECellIntegrator &integrator,
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
integrator.gather_evaluate(src, EvaluationFlags::gradients);
void
do_cell_integral_range(
- const MatrixFree<dim, number> & matrix_free,
- VectorType & dst,
- const VectorType & src,
+ const MatrixFree<dim, number> &matrix_free,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &range) const
{
FECellIntegrator integrator(matrix_free, range);
typename LevelMatrixType,
typename MGTransferType>
static void
-mg_solve(SolverControl & solver_control,
- VectorType & dst,
- const VectorType & src,
- const GMGParameters & mg_data,
- const DoFHandler<dim> & dof,
- const SystemMatrixType & fine_matrix,
+mg_solve(SolverControl &solver_control,
+ VectorType &dst,
+ const VectorType &src,
+ const GMGParameters &mg_data,
+ const DoFHandler<dim> &dof,
+ const SystemMatrixType &fine_matrix,
const MGLevelObject<LevelMatrixType> &mg_matrices,
- const MGTransferType & mg_transfer)
+ const MGTransferType &mg_transfer)
{
AssertThrow(mg_data.smoother.type == "chebyshev", ExcNotImplemented());
template <int dim, typename Number>
void
-do_test(const FiniteElement<dim> & fe_fine,
- const FiniteElement<dim> & fe_coarse,
+do_test(const FiniteElement<dim> &fe_fine,
+ const FiniteElement<dim> &fe_coarse,
const Function<dim, Number> &function)
{
// create coarse grid
template <int dim, typename Number>
void
-do_test(const FiniteElement<dim> & fe_fine,
- const FiniteElement<dim> & fe_coarse,
+do_test(const FiniteElement<dim> &fe_fine,
+ const FiniteElement<dim> &fe_coarse,
const Function<dim, Number> &function)
{
// create coarse grid
template <int dim, typename Number>
void
-do_test(const FiniteElement<dim> & fe_fine,
- const FiniteElement<dim> & fe_coarse,
+do_test(const FiniteElement<dim> &fe_fine,
+ const FiniteElement<dim> &fe_coarse,
const Function<dim, Number> &function)
{
// create coarse grid
template <int dim, typename Number>
void
-do_test(const FiniteElement<dim> & fe_fine,
- const FiniteElement<dim> & fe_coarse,
+do_test(const FiniteElement<dim> &fe_fine,
+ const FiniteElement<dim> &fe_coarse,
const Function<dim, Number> &function)
{
// create coarse grid
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const std::set<types::boundary_id> &dirichlet_boundaries,
const unsigned int level = numbers::invalid_unsigned_int)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const MGConstrainedDoFs &mg_constrained_dofs,
const std::map<types::boundary_id, const Function<dim> *>
- & dirichlet_boundary,
+ &dirichlet_boundary,
const unsigned int level = numbers::invalid_unsigned_int)
{
const QGauss<1> quad(n_q_points_1d);
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_down(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_up(
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
Assert(src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
}
void
- vmult(LinearAlgebra::distributed::Vector<double> & dst,
+ vmult(LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
laplace->vmult_interface_down(dst, src);
}
void
- Tvmult(LinearAlgebra::distributed::Vector<double> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
laplace->vmult_interface_up(dst, src);
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const MGConstrainedDoFs &mg_constrained_dofs,
const std::map<types::boundary_id, const Function<dim> *>
- & dirichlet_boundary,
+ &dirichlet_boundary,
const unsigned int level,
const bool threaded)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_down(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_up(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const MGConstrainedDoFs &mg_constrained_dofs,
const std::map<types::boundary_id, const Function<dim> *>
- & dirichlet_boundary,
+ &dirichlet_boundary,
const unsigned int level,
const bool threaded)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_down(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
void
vmult_interface_up(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
Assert(src.partitioners_are_globally_compatible(
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
}
void
- precondition_Jacobi(BlockVectorType & dst,
+ precondition_Jacobi(BlockVectorType &dst,
const BlockVectorType &src,
const value_type omega) const
{
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<double> & dst,
+ LinearAlgebra::distributed::Vector<double> &dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
}
void
- precondition_Jacobi(BlockVectorType & dst,
+ precondition_Jacobi(BlockVectorType &dst,
const BlockVectorType &src,
const value_type omega) const
{
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::BlockVector<Number> & dst,
+ LinearAlgebra::distributed::BlockVector<Number> &dst,
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
deallog.push("float");
}
else
- {}
+ {
+ }
for (unsigned int i = 0; i < dof.size(); ++i)
{
public:
void
initialize(std::shared_ptr<const MatrixFree<dim, Number>> data,
- const MGConstrainedDoFs & mg_constrained_dofs,
+ const MGConstrainedDoFs &mg_constrained_dofs,
const unsigned int level)
{
MatrixFreeOperators::Base<dim, LinearAlgebra::distributed::Vector<Number>>::
void
initialize(std::shared_ptr<const MatrixFree<dim, Number>> data,
- const std::vector<unsigned int> & mask = {})
+ const std::vector<unsigned int> &mask = {})
{
MatrixFreeOperators::Base<dim, LinearAlgebra::distributed::Vector<Number>>::
initialize(data, mask);
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
adjust_ghost_range_if_necessary(src);
private:
void
- local_apply(const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ local_apply(const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const std::set<types::boundary_id> &dirichlet_boundaries,
const unsigned int level = numbers::invalid_unsigned_int)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
}
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const std::set<types::boundary_id> &dirichlet_boundaries,
const unsigned int level = numbers::invalid_unsigned_int)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src, true);
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src);
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
}
void
- initialize(const Mapping<dim> & mapping,
- DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ DoFHandler<dim> &dof_handler,
const std::set<types::boundary_id> &dirichlet_boundaries,
const unsigned int level = numbers::invalid_unsigned_int)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src, true);
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src);
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const std::set<types::boundary_id> &dirichlet_boundaries,
const unsigned int level = numbers::invalid_unsigned_int)
{
}
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
dst = 0;
}
void
- Tvmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
vmult_add(dst, src);
}
void
- vmult_add(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
data.cell_loop(&LaplaceOperator::local_apply, this, dst, src);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
void
local_diagonal_cell(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
virtual void
operator()(const unsigned int level,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const
{
ReductionControl solver_control(1e4, 1e-50, 1e-10);
template <int dim>
double
- Coefficient<dim>::value(const Point<dim> & p,
+ Coefficient<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
return value<double>(p, component);
private:
virtual void
apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const override;
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_compute_diagonal(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
- const unsigned int & dummy,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
+ const unsigned int &dummy,
const std::pair<unsigned int, unsigned int> &cell_range) const;
Table<2, VectorizedArray<number>> coefficient;
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::local_apply(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(data);
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
this->data->cell_loop(&LaplaceOperator::local_apply, this, dst, src);
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::local_compute_diagonal(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
* the inverse of the S block (Schur complement matrix).
**/
BlockSchurPreconditioner(const StokesMatrixType &S,
- const MassMatrixType & Mass,
+ const MassMatrixType &Mass,
const PreconditionerMp &Mppreconditioner,
- const PreconditionerA & Apreconditioner,
+ const PreconditionerA &Apreconditioner,
const bool do_solve_A,
const double A_block_tolerance,
const double S_block_tolerance);
* Matrix vector product with this preconditioner object.
*/
void
- vmult(LinearAlgebra::distributed::BlockVector<double> & dst,
+ vmult(LinearAlgebra::distributed::BlockVector<double> &dst,
const LinearAlgebra::distributed::BlockVector<double> &src) const;
unsigned int
* References to the various matrix object this preconditioner works on.
*/
const StokesMatrixType &stokes_matrix;
- const MassMatrixType & mass_matrix;
+ const MassMatrixType &mass_matrix;
const PreconditionerMp &mp_preconditioner;
- const PreconditionerA & a_preconditioner;
+ const PreconditionerA &a_preconditioner;
/**
* Whether to actually invert the $\tilde A$ part of the preconditioner
PreconditionerA,
PreconditionerMp>::
BlockSchurPreconditioner(const StokesMatrixType &S,
- const MassMatrixType & Mass,
+ const MassMatrixType &Mass,
const PreconditionerMp &Mppreconditioner,
- const PreconditionerA & Apreconditioner,
+ const PreconditionerA &Apreconditioner,
const bool do_solve_A,
const double A_block_tolerance,
const double S_block_tolerance)
MassMatrixType,
PreconditionerA,
PreconditionerMp>::
- vmult(LinearAlgebra::distributed::BlockVector<double> & dst,
+ vmult(LinearAlgebra::distributed::BlockVector<double> &dst,
const LinearAlgebra::distributed::BlockVector<double> &src) const
{
LinearAlgebra::distributed::BlockVector<double> utmp(src);
value(const Point<dim> &p, const unsigned int component = 0) const;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
Sinker<dim> sinker;
template <int dim>
void
Viscosity<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
template <int dim>
void
RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
double Chi = 1.0;
for (unsigned int s = 0; s < sinker.n_sinkers; ++s)
void
ExactSolution_BoundaryValues_u<dim>::vector_value(
const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
(void)p;
for (unsigned int i = 0; i < values.size(); ++i)
private:
virtual void
- apply_add(LinearAlgebra::distributed::BlockVector<number> & dst,
+ apply_add(LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src) const;
void
- local_apply(const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::BlockVector<number> & dst,
+ local_apply(const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
template <int dim, int degree_v, typename number>
void
StokesOperator<dim, degree_v, number>::local_apply(
- const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::BlockVector<number> & dst,
+ const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<number>;
FEEvaluation<dim, degree_v, degree_v + 1, dim, number> velocity(data, 0);
template <int dim, int degree_v, typename number>
void
StokesOperator<dim, degree_v, number>::apply_add(
- LinearAlgebra::distributed::BlockVector<number> & dst,
+ LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src) const
{
MatrixFreeOperators::
private:
virtual void
- apply_add(LinearAlgebra::distributed::Vector<number> & dst,
+ apply_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const;
void
- local_apply(const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_compute_diagonal(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
- const unsigned int & dummy,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
+ const unsigned int &dummy,
const std::pair<unsigned int, unsigned int> &cell_range) const;
Table<2, VectorizedArray<number>> one_over_viscosity;
template <int dim, int degree_p, typename number>
void
MassMatrixOperator<dim, degree_p, number>::local_apply(
- const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree_p, degree_p + 2, 1, number> pressure(data);
template <int dim, int degree_p, typename number>
void
MassMatrixOperator<dim, degree_p, number>::apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
MatrixFreeOperators::Base<dim,
template <int dim, int degree_p, typename number>
void
MassMatrixOperator<dim, degree_p, number>::local_compute_diagonal(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
private:
virtual void
- apply_add(LinearAlgebra::distributed::Vector<number> & dst,
+ apply_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const;
void
- local_apply(const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_compute_diagonal(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
- const unsigned int & dummy,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
+ const unsigned int &dummy,
const std::pair<unsigned int, unsigned int> &cell_range) const;
Table<2, VectorizedArray<number>> viscosity_x_2;
template <int dim, int degree_v, typename number>
void
ABlockOperator<dim, degree_v, number>::local_apply(
- const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree_v, degree_v + 1, dim, number> velocity(data);
template <int dim, int degree_v, typename number>
void
ABlockOperator<dim, degree_v, number>::apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
MatrixFreeOperators::Base<dim,
template <int dim, int degree_v, typename number>
void
ABlockOperator<dim, degree_v, number>::local_compute_diagonal(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
mg_transfer.initialize_constraints(mg_constrained_dofs);
mg_transfer.build(dof_handler_u);
- LevelMatrixType & coarse_matrix = mg_matrices[0];
+ LevelMatrixType &coarse_matrix = mg_matrices[0];
SolverControl coarse_solver_control(1000, 1e-12, false, false);
SolverCG<vector_t> coarse_solver(coarse_solver_control);
void
extract_locally_active_level_dofs(const DoFHandler<dim> &dof_handler,
const unsigned int level,
- IndexSet & dof_set)
+ IndexSet &dof_set)
{
dof_set = IndexSet(dof_handler.n_dofs(level));
class MGCoarseAMG : public MGCoarseGridBase<VECTOR>
{
public:
- MGCoarseAMG(const LA::MPI::SparseMatrix & coarse_matrix,
+ MGCoarseAMG(const LA::MPI::SparseMatrix &coarse_matrix,
const LA::MPI::PreconditionAMG::AdditionalData additional_data)
: count(0)
{
void
LaplaceProblem<dim>::solve()
{
- matrix_t & coarse_matrix = mg_matrices[0];
+ matrix_t &coarse_matrix = mg_matrices[0];
SolverControl coarse_solver_control(1000, 1e-8, false, false);
SolverCG<vector_t> coarse_solver(coarse_solver_control);
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
private:
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
class MGCoarseAMG : public MGCoarseGridBase<VECTOR>
{
public:
- MGCoarseAMG(const LA::MPI::SparseMatrix & coarse_matrix,
+ MGCoarseAMG(const LA::MPI::SparseMatrix &coarse_matrix,
const LA::MPI::PreconditionAMG::AdditionalData additional_data)
: count(0)
{
void
LaplaceProblem<dim>::solve()
{
- matrix_t & coarse_matrix = mg_matrices[0];
+ matrix_t &coarse_matrix = mg_matrices[0];
SolverControl coarse_solver_control(1000, 1e-8, false, false);
SolverCG<vector_t> coarse_solver(coarse_solver_control);
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_level(); ++level)
{
void
print_diff(const DoFHandler<dim> &dof_1,
const DoFHandler<dim> &dof_2,
- const Vector<double> & u,
- const Vector<double> & v)
+ const Vector<double> &u,
+ const Vector<double> &v)
{
Vector<double> diff;
diff.reinit(u);
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_level(); ++level)
{
void
print_diff(const DoFHandler<dim> &dof_1,
const DoFHandler<dim> &dof_2,
- const Vector<double> & u,
- const Vector<double> & v)
+ const Vector<double> &u,
+ const Vector<double> &v)
{
Vector<double> diff;
diff.reinit(u);
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_level(); ++level)
{
void
print_diff(const DoFHandler<dim> &dof_1,
const DoFHandler<dim> &dof_2,
- const Vector<double> & u,
- const Vector<double> & v)
+ const Vector<double> &u,
+ const Vector<double> &v)
{
Vector<double> diff;
diff.reinit(u);
template <int dim>
void
-print(const DoFHandler<dim> & dof,
+print(const DoFHandler<dim> &dof,
std::vector<std::vector<bool>> &interface_dofs)
{
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_level(); ++level)
{
template <int dim>
void
-diff(Vector<double> & diff,
+diff(Vector<double> &diff,
const DoFHandler<dim> &dof,
- const Vector<double> & v,
+ const Vector<double> &v,
const unsigned int level)
{
diff.reinit(v);
template <int dim>
void
-OutputCreator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+OutputCreator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info)
{
- const FEValuesBase<dim> & fe = info.fe_values();
+ const FEValuesBase<dim> &fe = info.fe_values();
const std::vector<std::vector<double>> &uh = info.values[0];
const unsigned int square_root =
template <int dim>
void
-LaplaceProblem<dim>::output_gpl(const DoFHandler<dim> & dof,
+LaplaceProblem<dim>::output_gpl(const DoFHandler<dim> &dof,
MGLevelObject<Vector<double>> &v)
{
MeshWorker::IntegrationInfoBox<dim> info_box;
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_level(); ++level)
{
template <int dim>
void
-diff(Vector<double> & diff,
+diff(Vector<double> &diff,
const DoFHandler<dim> &dof,
- const Vector<double> & v,
+ const Vector<double> &v,
const unsigned int level)
{
diff.reinit(v);
template <int dim>
void
-diff(Vector<double> & diff,
+diff(Vector<double> &diff,
const DoFHandler<dim> &dof_1,
const DoFHandler<dim> &dof_2,
- const Vector<double> & u,
- const Vector<double> & v,
+ const Vector<double> &u,
+ const Vector<double> &v,
const unsigned int level)
{
diff.reinit(u);
template <int dim>
void
-print(const DoFHandler<dim> & dof,
+print(const DoFHandler<dim> &dof,
std::vector<std::vector<bool>> &interface_dofs)
{
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
template <int dim>
void
-OutputCreator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+OutputCreator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info)
{
- const FEValuesBase<dim> & fe = info.fe_values();
+ const FEValuesBase<dim> &fe = info.fe_values();
const std::vector<std::vector<double>> &uh = info.values[0];
const unsigned int square_root =
template <int dim>
void
-LaplaceProblem<dim>::output_gpl(const DoFHandler<dim> & dof,
+LaplaceProblem<dim>::output_gpl(const DoFHandler<dim> &dof,
MGLevelObject<Vector<double>> &v)
{
MeshWorker::IntegrationInfoBox<dim> info_box;
public:
LaplaceMatrix();
virtual void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info) const;
virtual void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info) const;
virtual void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
MeshWorker::IntegrationInfo<dim> &info1,
MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
-LaplaceMatrix<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+LaplaceMatrix<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info) const
{
AssertDimension(dinfo.n_matrices(), 1);
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
local_dof_indices[j]) // ( boundary(i) && boundary(j)
// && i==j )
))
- {}
+ {
+ }
else
{
cell_matrix(i, j) = 0;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
local_dof_indices[j]) // ( boundary(i) && boundary(j)
// && i==j )
))
- {}
+ {
+ }
else
{
cell_matrix(i, j) = 0;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
local_dof_indices[j]) // ( boundary(i) && boundary(j)
// && i==j )
))
- {}
+ {
+ }
else
{
cell_matrix(i, j) = 0;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
local_dof_indices[j]) // ( boundary(i) && boundary(j) &&
// i==j )
))
- {}
+ {
+ }
else
{
cell_matrix(i, j) = 0;
public:
LaplaceMatrix();
virtual void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info) const;
virtual void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info) const;
virtual void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
MeshWorker::IntegrationInfo<dim> &info1,
MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
-LaplaceMatrix<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+LaplaceMatrix<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
MeshWorker::IntegrationInfo<dim> &info) const
{
AssertDimension(dinfo.n_matrices(), 1);
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().tensor_degree();
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
RHSIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
- Vector<double> & local_vector = dinfo.vector(0).block(0);
+ Vector<double> &local_vector = dinfo.vector(0).block(0);
std::vector<double> boundary_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), boundary_values);
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
- Estimator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+ Estimator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
Estimator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
- Estimator<dim>::face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ Estimator<dim>::face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
- const std::vector<double> & uh1 = info1.values[0][0];
- const std::vector<double> & uh2 = info2.values[0][0];
+ const FEValuesBase<dim> &fe = info1.fe_values();
+ const std::vector<double> &uh1 = info1.values[0][0];
+ const std::vector<double> &uh2 = info2.values[0][0];
const std::vector<Tensor<1, dim>> &Duh1 = info1.gradients[0][0];
const std::vector<Tensor<1, dim>> &Duh2 = info2.gradients[0][0];
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
ErrorIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
- const FEValuesBase<dim> & fe = info.fe_values();
+ const FEValuesBase<dim> &fe = info.fe_values();
std::vector<Tensor<1, dim>> exact_gradients(fe.n_quadrature_points);
std::vector<double> exact_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), exact_values);
const std::vector<Tensor<1, dim>> &Duh = info.gradients[0][0];
- const std::vector<double> & uh = info.values[0][0];
+ const std::vector<double> &uh = info.values[0][0];
for (unsigned k = 0; k < fe.n_quadrature_points; ++k)
{
template <int dim>
void
ErrorIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
ErrorIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
+ const FEValuesBase<dim> &fe = info1.fe_values();
const std::vector<double> &uh1 = info1.values[0][0];
const std::vector<double> &uh2 = info2.values[0][0];
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().tensor_degree();
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
RHSIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
- Vector<double> & local_vector = dinfo.vector(0).block(0);
+ Vector<double> &local_vector = dinfo.vector(0).block(0);
std::vector<double> boundary_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), boundary_values);
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
- Estimator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+ Estimator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
Estimator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
- Estimator<dim>::face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ Estimator<dim>::face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
- const std::vector<double> & uh1 = info1.values[0][0];
- const std::vector<double> & uh2 = info2.values[0][0];
+ const FEValuesBase<dim> &fe = info1.fe_values();
+ const std::vector<double> &uh1 = info1.values[0][0];
+ const std::vector<double> &uh2 = info2.values[0][0];
const std::vector<Tensor<1, dim>> &Duh1 = info1.gradients[0][0];
const std::vector<Tensor<1, dim>> &Duh2 = info2.gradients[0][0];
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
ErrorIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
- const FEValuesBase<dim> & fe = info.fe_values();
+ const FEValuesBase<dim> &fe = info.fe_values();
std::vector<Tensor<1, dim>> exact_gradients(fe.n_quadrature_points);
std::vector<double> exact_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), exact_values);
const std::vector<Tensor<1, dim>> &Duh = info.gradients[0][0];
- const std::vector<double> & uh = info.values[0][0];
+ const std::vector<double> &uh = info.values[0][0];
for (unsigned k = 0; k < fe.n_quadrature_points; ++k)
{
template <int dim>
void
ErrorIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
ErrorIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
+ const FEValuesBase<dim> &fe = info1.fe_values();
const std::vector<double> &uh1 = info1.values[0][0];
const std::vector<double> &uh2 = info2.values[0][0];
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().tensor_degree();
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
RHSIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
- Vector<double> & local_vector = dinfo.vector(0).block(0);
+ Vector<double> &local_vector = dinfo.vector(0).block(0);
std::vector<double> boundary_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), boundary_values);
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
- Estimator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+ Estimator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
Estimator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
- Estimator<dim>::face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ Estimator<dim>::face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
- const std::vector<double> & uh1 = info1.values[0][0];
- const std::vector<double> & uh2 = info2.values[0][0];
+ const FEValuesBase<dim> &fe = info1.fe_values();
+ const std::vector<double> &uh1 = info1.values[0][0];
+ const std::vector<double> &uh2 = info2.values[0][0];
const std::vector<Tensor<1, dim>> &Duh1 = info1.gradients[0][0];
const std::vector<Tensor<1, dim>> &Duh2 = info2.gradients[0][0];
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
ErrorIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
- const FEValuesBase<dim> & fe = info.fe_values();
+ const FEValuesBase<dim> &fe = info.fe_values();
std::vector<Tensor<1, dim>> exact_gradients(fe.n_quadrature_points);
std::vector<double> exact_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), exact_values);
const std::vector<Tensor<1, dim>> &Duh = info.gradients[0][0];
- const std::vector<double> & uh = info.values[0][0];
+ const std::vector<double> &uh = info.values[0][0];
for (unsigned k = 0; k < fe.n_quadrature_points; ++k)
{
template <int dim>
void
ErrorIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
ErrorIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
+ const FEValuesBase<dim> &fe = info1.fe_values();
const std::vector<double> &uh1 = info1.values[0][0];
const std::vector<double> &uh2 = info2.values[0][0];
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().tensor_degree();
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
RHSIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
- Vector<double> & local_vector = dinfo.vector(0).block(0);
+ Vector<double> &local_vector = dinfo.vector(0).block(0);
std::vector<double> boundary_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), boundary_values);
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
- Estimator<dim>::cell(MeshWorker::DoFInfo<dim> & dinfo,
+ Estimator<dim>::cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
Estimator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
- Estimator<dim>::face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ Estimator<dim>::face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
- const std::vector<double> & uh1 = info1.values[0][0];
- const std::vector<double> & uh2 = info2.values[0][0];
+ const FEValuesBase<dim> &fe = info1.fe_values();
+ const std::vector<double> &uh1 = info1.values[0][0];
+ const std::vector<double> &uh2 = info2.values[0][0];
const std::vector<Tensor<1, dim>> &Duh1 = info1.gradients[0][0];
const std::vector<Tensor<1, dim>> &Duh2 = info2.gradients[0][0];
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
ErrorIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
- const FEValuesBase<dim> & fe = info.fe_values();
+ const FEValuesBase<dim> &fe = info.fe_values();
std::vector<Tensor<1, dim>> exact_gradients(fe.n_quadrature_points);
std::vector<double> exact_values(fe.n_quadrature_points);
exact_solution.value_list(fe.get_quadrature_points(), exact_values);
const std::vector<Tensor<1, dim>> &Duh = info.gradients[0][0];
- const std::vector<double> & uh = info.values[0][0];
+ const std::vector<double> &uh = info.values[0][0];
for (unsigned k = 0; k < fe.n_quadrature_points; ++k)
{
template <int dim>
void
ErrorIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const FEValuesBase<dim> &fe = info.fe_values();
template <int dim>
void
ErrorIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
- const FEValuesBase<dim> & fe = info1.fe_values();
+ const FEValuesBase<dim> &fe = info1.fe_values();
const std::vector<double> &uh1 = info1.values[0][0];
const std::vector<double> &uh2 = info2.values[0][0];
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
private:
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
const unsigned int n_points = points.size();
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
template <int dim>
void
Coefficient<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
(void)component;
local_dof_indices[j]) // ( boundary(i) && boundary(j)
// && i==j )
))
- {}
+ {
+ }
else
{
cell_matrix(i, j) = 0;
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_level(); ++level)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_level(); ++level)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_level(); ++level)
{
void
print_diff(const DoFHandler<dim> &dof_1,
const DoFHandler<dim> &dof_2,
- const Vector<double> & u,
- const Vector<double> & v)
+ const Vector<double> &u,
+ const Vector<double> &v)
{
Vector<double> diff;
diff.reinit(u);
template <int dim, typename number, int spacedim>
void
reinit_vector_by_blocks(
- const dealii::DoFHandler<dim, spacedim> & mg_dof,
- MGLevelObject<BlockVector<number>> & v,
- const std::vector<bool> & sel,
+ const dealii::DoFHandler<dim, spacedim> &mg_dof,
+ MGLevelObject<BlockVector<number>> &v,
+ const std::vector<bool> &sel,
std::vector<std::vector<types::global_dof_index>> &ndofs)
{
std::vector<bool> selected = sel;
template <int dim>
void
-check_block(const FiniteElement<dim> & fe,
- const std::vector<bool> & selected,
+check_block(const FiniteElement<dim> &fe,
+ const std::vector<bool> &selected,
const std::vector<double> &factors)
{
deallog << fe.get_name() << std::endl << "selected ";
template <int dim, typename number, int spacedim>
void
reinit_vector_by_blocks(
- const dealii::DoFHandler<dim, spacedim> & mg_dof,
- MGLevelObject<dealii::Vector<number>> & v,
+ const dealii::DoFHandler<dim, spacedim> &mg_dof,
+ MGLevelObject<dealii::Vector<number>> &v,
const unsigned int selected_block,
std::vector<std::vector<types::global_dof_index>> &ndofs)
{
template <int dim, typename number, int spacedim>
void
reinit_vector_by_blocks(
- const dealii::DoFHandler<dim, spacedim> & mg_dof,
- MGLevelObject<dealii::Vector<number>> & v,
+ const dealii::DoFHandler<dim, spacedim> &mg_dof,
+ MGLevelObject<dealii::Vector<number>> &v,
const unsigned int selected_block,
std::vector<std::vector<types::global_dof_index>> &ndofs)
{
template <int dim, typename number, int spacedim>
void
reinit_vector_by_blocks(
- const dealii::DoFHandler<dim, spacedim> & mg_dof,
- MGLevelObject<BlockVector<number>> & v,
- const std::vector<bool> & sel,
+ const dealii::DoFHandler<dim, spacedim> &mg_dof,
+ MGLevelObject<BlockVector<number>> &v,
+ const std::vector<bool> &sel,
std::vector<std::vector<types::global_dof_index>> &ndofs)
{
std::vector<bool> selected = sel;
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
template <int dim, typename number, int spacedim>
void
reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> & v)
+ MGLevelObject<dealii::Vector<number>> &v)
{
for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
{
template <typename Transfer>
void
-make_matrix(const Transfer & transfer,
+make_matrix(const Transfer &transfer,
const unsigned int high_level,
FullMatrix<double> &matrix)
{
// C++ standard library):
template <int dim>
double
-RightHandSide<dim>::value(const Point<dim> & p,
+RightHandSide<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
template <int dim>
double
-BoundaryValues<dim>::value(const Point<dim> & p,
+BoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
(void)component;
void
local_assemble_system(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- AssemblyScratchData<dim> & scratch_data,
- AssemblyCopyData & copy_data)
+ AssemblyScratchData<dim> &scratch_data,
+ AssemblyCopyData ©_data)
{
// We define some abbreviations to avoid unnecessarily long lines:
const unsigned int dofs_per_cell =
auto worker = [&](const typename DoFHandler<dim>::active_cell_iterator &cell,
AssemblyScratchData<dim> &scratch_data,
- AssemblyCopyData & copy_data) {
+ AssemblyCopyData ©_data) {
local_assemble_system(cell, scratch_data, copy_data);
};
typename ScratchData,
typename CopyData>
void
- run(const Iterator & begin,
+ run(const Iterator &begin,
const std_cxx20::type_identity_t<Iterator> &end,
Worker worker,
Copier copier,
- const ScratchData & sample_scratch_data,
- const CopyData & sample_copy_data,
+ const ScratchData &sample_scratch_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length = 2 * MultithreadInfo::n_threads(),
const unsigned int chunk_size = 8)
{
&worker]() {
// std::cout << "worker " << idx << std::endl;
ScratchData scratch = sample_scratch_data;
- auto & copy = copy_datas[idx];
+ auto © = copy_datas[idx];
copy =
std::make_unique<CopyData>(sample_copy_data);
typename ScratchData,
typename CopyData>
void
- run(const Iterator & begin,
+ run(const Iterator &begin,
const std_cxx20::type_identity_t<Iterator> &end,
- MainClass & main_object,
+ MainClass &main_object,
void (MainClass::*worker)(const Iterator &, ScratchData &, CopyData &),
void (MainClass::*copier)(const CopyData &),
const ScratchData &sample_scratch_data,
- const CopyData & sample_copy_data,
+ const CopyData &sample_copy_data,
const unsigned int queue_length = 2 * MultithreadInfo::n_threads(),
const unsigned int chunk_size = 8)
{
begin,
end,
[&main_object, worker](const Iterator &iterator,
- ScratchData & scratch_data,
- CopyData & copy_data) {
+ ScratchData &scratch_data,
+ CopyData ©_data) {
(main_object.*worker)(iterator, scratch_data, copy_data);
},
[&main_object, copier](const CopyData ©_data) {
{}
const FiniteElement<dim> &fe_collection;
- const Quadrature<dim> & quadrature_collection;
+ const Quadrature<dim> &quadrature_collection;
FEValues<dim> x_fe_values;
template <int dim>
void
mass_assembler(const typename Triangulation<dim>::active_cell_iterator &cell,
- Scratch<dim> & data,
+ Scratch<dim> &data,
CopyData ©_data)
{
data.x_fe_values.reinit(cell);
{}
const FiniteElement<dim> &fe_collection;
- const Quadrature<dim> & quadrature_collection;
+ const Quadrature<dim> &quadrature_collection;
FEValues<dim> x_fe_values;
template <int dim>
void
mass_assembler(const typename Triangulation<dim>::active_cell_iterator &cell,
- Scratch<dim> & data,
+ Scratch<dim> &data,
CopyData ©_data)
{
data.x_fe_values.reinit(cell);
const MappingQ<dim> mapping_q(polynomial_degree);
const std::vector<std::string> mapping_names = {"MappingCartesian",
- "MappingQ"};
+ "MappingQ"};
const hp::MappingCollection<dim> mappings(mapping_cartesian, mapping_q);
for (unsigned int i = 0; i < mappings.size(); i++)
check_get_normals(
const NonMatching::ImmersedSurfaceQuadrature<dim, spacedim> &quadrature)
{
- const std::vector<Point<dim>> & points = quadrature.get_points();
+ const std::vector<Point<dim>> &points = quadrature.get_points();
const std::vector<Tensor<1, dim>> &normals = quadrature.get_normal_vectors();
AssertThrow(points.size() == normals.size(), ExcInternalError())
}
non_matching_fe_values.get_surface_fe_values();
- auto test_fe_values = [&](const auto & fe_values,
+ auto test_fe_values = [&](const auto &fe_values,
std::vector<double> &solution_values_out,
- Vector<double> & dst) {
+ Vector<double> &dst) {
if (fe_values)
{
std::vector<Tensor<1, dim>> solution_gradients(
template <int dim>
void
print_cell_and_face_locations(
- const NonMatching::MeshClassifier<dim> & classifier,
+ const NonMatching::MeshClassifier<dim> &classifier,
const typename Triangulation<dim>::active_cell_iterator &cell)
{
const NonMatching::LocationToLevelSet cell_location =
template <int dim>
void
create_and_print_quadratures(
- const Function<dim> & level_set,
+ const Function<dim> &level_set,
const unsigned int n_1D_points = 2,
const typename QuadratureGenerator<dim>::AdditionalData &additional_data =
typename QuadratureGenerator<dim>::AdditionalData())
};
Tensor<1, 1>
- gradient(const Point<1> & point,
+ gradient(const Point<1> &point,
const unsigned int component = 0) const override
{
Tensor<1, 1> grad;
};
SymmetricTensor<2, 1>
- hessian(const Point<1> & point,
+ hessian(const Point<1> &point,
const unsigned int component = 0) const override
{
SymmetricTensor<2, 1> grad;
// namespace facilities. At the top, we read the file into a triangulation:
template <int dim, int spacedim>
void
- read_grid_and_cad_files(const std::string & grid_file_name,
- const std::string & ids_and_cad_file_names,
+ read_grid_and_cad_files(const std::string &grid_file_name,
+ const std::string &ids_and_cad_file_names,
Triangulation<dim, spacedim> &tria)
{
GridIn<dim, spacedim> grid_in;
struct Data
{
Data(const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature)
+ const hp::QCollection<dim> &quadrature)
: hp_fe_values(fe,
quadrature,
update_values | update_gradients |
void
local_assemble(const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data);
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
void
LaplaceProblem<dim>::local_assemble(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data)
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
struct Data
{
Data(const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature)
+ const hp::QCollection<dim> &quadrature)
: hp_fe_values(fe,
quadrature,
update_values | update_gradients |
void
local_assemble(const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data);
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
void
LaplaceProblem<dim>::local_assemble(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data)
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
struct Data
{
Data(const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature)
+ const hp::QCollection<dim> &quadrature)
: hp_fe_values(fe,
quadrature,
update_values | update_gradients |
void
local_assemble(const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data);
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
void
LaplaceProblem<dim>::local_assemble(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data)
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
struct Data
{
Data(const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature)
+ const hp::QCollection<dim> &quadrature)
: hp_fe_values(fe,
quadrature,
update_values | update_gradients |
void
local_assemble(const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data);
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
void
LaplaceProblem<dim>::local_assemble(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data)
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
dof,
quadrature,
matrix,
- (const Function<dim> *const) nullptr,
+ (const Function<dim> *const)nullptr,
constraints);
// compute reference: need to cancel constrained entries as these will in
template <int dim>
void
check(const unsigned int level,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &element,
- const Quadrature<dim> & quadrature)
+ const Quadrature<dim> &quadrature)
{
Triangulation<dim> tr;
void
output(const std::string name,
const Triangulation<dim> &triangulation,
- const DoFHandler<dim> & dof_handler,
- const Vector<double> & values,
- const Vector<float> & error)
+ const DoFHandler<dim> &dof_handler,
+ const Vector<double> &values,
+ const Vector<float> &error)
{
dealii::Vector<double> fe_degrees(triangulation.n_active_cells());
{
template <int dim>
void
output(const std::string name,
- const Triangulation<dim> & triangulation,
- const DoFHandler<dim> & dof_handler,
+ const Triangulation<dim> &triangulation,
+ const DoFHandler<dim> &dof_handler,
const Vector<std::complex<double>> &values,
- const Vector<float> & error)
+ const Vector<float> &error)
{
dealii::Vector<double> fe_degrees(triangulation.n_active_cells());
{
template <int dim, typename T>
void
test(const FiniteElement<dim> &fe,
- const T & f,
+ const T &f,
const unsigned int order_mapping,
bool distort_mesh,
bool print_function_values = false)
void
colorize_sixty_deg_hyper_shell(Triangulation<3> &tria,
- const Point<3> & center,
+ const Point<3> ¢er,
const double inner_radius,
const double outer_radius)
{
void
sixty_deg_hyper_shell(Triangulation<3> &tria,
- const Point<3> & center,
+ const Point<3> ¢er,
const double inner_radius,
const double outer_radius)
{
template <int dim>
void
get_constraints_on_active_cells(
- const Triangulation<dim> & tria,
+ const Triangulation<dim> &tria,
const std::set<types::boundary_id> &no_normal_flux_boundaries,
- AffineConstraints<double> & constraints)
+ AffineConstraints<double> &constraints)
{
MappingQ<dim> mapping(4);
template <int dim>
void
get_constraints_on_levels(
- const Triangulation<dim> & triangulation,
- const std::set<types::boundary_id> & no_flux_boundary,
+ const Triangulation<dim> &triangulation,
+ const std::set<types::boundary_id> &no_flux_boundary,
MGLevelObject<AffineConstraints<double>> &level_constraints)
{
FESystem<dim> fe(FE_Q<dim>(1), dim);
template <int dim>
void
-run(Triangulation<dim> & triangulation,
+run(Triangulation<dim> &triangulation,
std::set<types::boundary_id> no_flux_boundary)
{
const unsigned int n_levels = 2;
* the inverse of the S block (Schur complement matrix).
**/
BlockSchurPreconditioner(const StokesMatrixType &S,
- const MassMatrixType & Mass,
+ const MassMatrixType &Mass,
const PreconditionerMp &Mppreconditioner,
- const PreconditionerA & Apreconditioner,
+ const PreconditionerA &Apreconditioner,
const bool do_solve_A,
const double A_block_tolerance,
const double S_block_tolerance);
* Matrix vector product with this preconditioner object.
*/
void
- vmult(LinearAlgebra::distributed::BlockVector<double> & dst,
+ vmult(LinearAlgebra::distributed::BlockVector<double> &dst,
const LinearAlgebra::distributed::BlockVector<double> &src) const;
unsigned int
* References to the various matrix object this preconditioner works on.
*/
const StokesMatrixType &stokes_matrix;
- const MassMatrixType & mass_matrix;
+ const MassMatrixType &mass_matrix;
const PreconditionerMp &mp_preconditioner;
- const PreconditionerA & a_preconditioner;
+ const PreconditionerA &a_preconditioner;
/**
* Whether to actually invert the $\tilde A$ part of the preconditioner
PreconditionerA,
PreconditionerMp>::
BlockSchurPreconditioner(const StokesMatrixType &S,
- const MassMatrixType & Mass,
+ const MassMatrixType &Mass,
const PreconditionerMp &Mppreconditioner,
- const PreconditionerA & Apreconditioner,
+ const PreconditionerA &Apreconditioner,
const bool do_solve_A,
const double A_block_tolerance,
const double S_block_tolerance)
MassMatrixType,
PreconditionerA,
PreconditionerMp>::
- vmult(LinearAlgebra::distributed::BlockVector<double> & dst,
+ vmult(LinearAlgebra::distributed::BlockVector<double> &dst,
const LinearAlgebra::distributed::BlockVector<double> &src) const
{
LinearAlgebra::distributed::BlockVector<double> utmp(src);
value(const Point<dim> &p, const unsigned int component = 0) const;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
Sinker<dim> sinker;
template <int dim>
void
Viscosity<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert(values.size() == points.size(),
template <int dim>
void
RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
double Chi = 1.0;
for (unsigned int s = 0; s < sinker.n_sinkers; ++s)
void
ExactSolution_BoundaryValues_u<dim>::vector_value(
const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
(void)p;
for (unsigned int i = 0; i < values.size(); ++i)
private:
virtual void
- apply_add(LinearAlgebra::distributed::BlockVector<number> & dst,
+ apply_add(LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src) const;
void
- local_apply(const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::BlockVector<number> & dst,
+ local_apply(const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
template <int dim, int degree_v, typename number>
void
StokesOperator<dim, degree_v, number>::local_apply(
- const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::BlockVector<number> & dst,
+ const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
using vector_t = VectorizedArray<number>;
FEEvaluation<dim, degree_v, degree_v + 1, dim, number> velocity(data, 0);
template <int dim, int degree_v, typename number>
void
StokesOperator<dim, degree_v, number>::apply_add(
- LinearAlgebra::distributed::BlockVector<number> & dst,
+ LinearAlgebra::distributed::BlockVector<number> &dst,
const LinearAlgebra::distributed::BlockVector<number> &src) const
{
MatrixFreeOperators::
private:
virtual void
- apply_add(LinearAlgebra::distributed::Vector<number> & dst,
+ apply_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const;
void
- local_apply(const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_compute_diagonal(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
- const unsigned int & dummy,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
+ const unsigned int &dummy,
const std::pair<unsigned int, unsigned int> &cell_range) const;
Table<2, VectorizedArray<number>> one_over_viscosity;
template <int dim, int degree_p, typename number>
void
MassMatrixOperator<dim, degree_p, number>::local_apply(
- const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree_p, degree_p + 2, 1, number> pressure(data);
template <int dim, int degree_p, typename number>
void
MassMatrixOperator<dim, degree_p, number>::apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
MatrixFreeOperators::Base<dim,
template <int dim, int degree_p, typename number>
void
MassMatrixOperator<dim, degree_p, number>::local_compute_diagonal(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
private:
virtual void
- apply_add(LinearAlgebra::distributed::Vector<number> & dst,
+ apply_add(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const;
void
- local_apply(const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_compute_diagonal(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
- const unsigned int & dummy,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
+ const unsigned int &dummy,
const std::pair<unsigned int, unsigned int> &cell_range) const;
Table<2, VectorizedArray<number>> viscosity_x_2;
template <int dim, int degree_v, typename number>
void
ABlockOperator<dim, degree_v, number>::local_apply(
- const dealii::MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const dealii::MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree_v, degree_v + 1, dim, number> velocity(data);
template <int dim, int degree_v, typename number>
void
ABlockOperator<dim, degree_v, number>::apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
MatrixFreeOperators::Base<dim,
template <int dim, int degree_v, typename number>
void
ABlockOperator<dim, degree_v, number>::local_compute_diagonal(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
// mg_constrained_dofs.get_boundary_indices(level));
MappingQ<dim> mapping(1);
- const auto & refinement_edge_indices =
+ const auto &refinement_edge_indices =
mg_constrained_dofs.get_refinement_edge_indices(level);
VectorTools::compute_no_normal_flux_constraints_on_level(
mg_transfer.initialize_constraints(mg_constrained_dofs);
mg_transfer.build(dof_handler_u);
- LevelMatrixType & coarse_matrix = mg_matrices[0];
+ LevelMatrixType &coarse_matrix = mg_matrices[0];
SolverControl coarse_solver_control(1000, 1e-12, false, false);
SolverCG<vector_t> coarse_solver(coarse_solver_control);
setup_system(const bool initial_step);
void
solve(const Vector<double> &rhs,
- Vector<double> & solution,
+ Vector<double> &solution,
const double tolerance);
void
refine_mesh();
compute_and_factorize_jacobian(const Vector<double> &evaluation_point);
void
compute_residual(const Vector<double> &evaluation_point,
- Vector<double> & residual);
+ Vector<double> &residual);
Triangulation<dim> triangulation;
void
MinimalSurfaceProblem<dim>::compute_residual(
const Vector<double> &evaluation_point,
- Vector<double> & residual)
+ Vector<double> &residual)
{
deallog << " Computing residual vector..." << std::flush;
residual = 0.;
template <int dim>
void
MinimalSurfaceProblem<dim>::solve(const Vector<double> &rhs,
- Vector<double> & solution,
+ Vector<double> &solution,
const double /*tolerance*/)
{
deallog << " Solving linear system" << std::endl;
};
nonlinear_solver.residual = [&](const Vector<double> &evaluation_point,
- Vector<double> & residual) {
+ Vector<double> &residual) {
compute_residual(evaluation_point, residual);
};
};
nonlinear_solver.solve_with_jacobian = [&](const Vector<double> &rhs,
- Vector<double> & dst,
+ Vector<double> &dst,
const double tolerance) {
solve(rhs, dst, tolerance);
};
setup_system(const bool initial_step);
void
solve(const LA::MPI::Vector &rhs,
- LA::MPI::Vector & solution,
+ LA::MPI::Vector &solution,
const double tolerance);
void
compute_and_factorize_jacobian(const LA::MPI::Vector &evaluation_point);
void
compute_residual(const LA::MPI::Vector &evaluation_point,
- LA::MPI::Vector & residual);
+ LA::MPI::Vector &residual);
MPI_Comm mpi_communicator;
void
MinimalSurfaceProblem<dim>::compute_residual(
const LA::MPI::Vector &evaluation_point,
- LA::MPI::Vector & residual)
+ LA::MPI::Vector &residual)
{
deallog << " Computing residual vector..." << std::flush;
residual = 0.;
template <int dim>
void
MinimalSurfaceProblem<dim>::solve(const LA::MPI::Vector &rhs,
- LA::MPI::Vector & solution,
+ LA::MPI::Vector &solution,
const double /*tolerance*/)
{
deallog << " Solving linear system" << std::endl;
};
nonlinear_solver.residual = [&](const LA::MPI::Vector &evaluation_point,
- LA::MPI::Vector & residual) {
+ LA::MPI::Vector &residual) {
compute_residual(evaluation_point, residual);
};
};
nonlinear_solver.solve_with_jacobian = [&](const LA::MPI::Vector &rhs,
- LA::MPI::Vector & dst,
+ LA::MPI::Vector &dst,
const double tolerance) {
solve(rhs, dst, tolerance);
};
}
// Get the location of all boundary dofs
std::vector<types::global_dof_index> face_dofs;
- const std::vector<Point<dim - 1>> & unit_support_points =
+ const std::vector<Point<dim - 1>> &unit_support_points =
fe.get_unit_face_support_points();
Quadrature<dim - 1> quadrature(unit_support_points);
FEFaceValues<dim, dim> fe_face_values(fe,
void
Postprocess<dim>::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
Assert(computed_quantities.size() == inputs.solution_values.size(),
ExcDimensionMismatch(computed_quantities.size(),
void
Postprocess<dim>::evaluate_scalar_field(
const DataPostprocessorInputs::Scalar<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
Assert(computed_quantities.size() == inputs.solution_values.size(),
ExcDimensionMismatch(computed_quantities.size(),
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & values) const;
+ std::vector<Vector<double>> &values) const;
private:
unsigned int degree;
template <int dim>
double
integrate_error(const DoFHandler<dim> &dof,
- FEFaceValues<dim> & fe,
- const Vector<double> & u,
- const Function<dim> & f)
+ FEFaceValues<dim> &fe,
+ const Vector<double> &u,
+ const Function<dim> &f)
{
double result = 0.;
std::vector<Vector<double>> f_values(fe.n_quadrature_points,
template <int dim>
void
-test_boundary_values(const FiniteElement<dim> & fe,
+test_boundary_values(const FiniteElement<dim> &fe,
AffineConstraints<double> &constraints)
{
Triangulation<dim> triangulation;
const unsigned int dim = 3;
void
-apply_boundary_values(DoFHandler<dim> & dof_handler,
+apply_boundary_values(DoFHandler<dim> &dof_handler,
AffineConstraints<double> &constraints,
unsigned int n_comps,
unsigned int start_comp,
- Mapping<dim> & mapping,
- Vector<double> & dst)
+ Mapping<dim> &mapping,
+ Vector<double> &dst)
{
constraints.clear();
for (unsigned int i = 0; i < 6; ++i)
bool
-test_boundary_values(DoFHandler<dim> & dof_handler,
- Mapping<dim> & mapping,
+test_boundary_values(DoFHandler<dim> &dof_handler,
+ Mapping<dim> &mapping,
FiniteElement<dim> &fe,
unsigned int n_comps,
unsigned int start_comp,
- Vector<double> & vec)
+ Vector<double> &vec)
{
// Initialize
QGaussLobatto<dim - 1> quadrature(3);
{}
virtual double
- value(const Point<dim> & point,
+ value(const Point<dim> &point,
const unsigned int component = 0) const override
{
Assert(component < dim, ExcNotImplemented());
{}
virtual double
- value(const Point<dim> & point,
+ value(const Point<dim> &point,
const unsigned int component = 0) const override
{
Assert(component < dim, ExcNotImplemented());
// To make interpolate_boundary_values happy, the pressure is assigned to
// the 2*dim + 1th component
virtual double
- value(const Point<dim> & point,
+ value(const Point<dim> &point,
const unsigned int component = 0) const override
{
if (component != 2 * dim)
template <int dim, int components, int fe_degree>
void
do_project(const parallel::distributed::Triangulation<dim> &triangulation,
- const FiniteElement<dim> & fe,
+ const FiniteElement<dim> &fe,
const unsigned int order_difference)
{
const unsigned int p = fe_degree;
template <typename VectorType, int dim>
void
do_project(const parallel::distributed::Triangulation<dim> &triangulation,
- const FiniteElement<dim> & fe,
+ const FiniteElement<dim> &fe,
const unsigned int p)
{
AssertThrow(fe.n_components() == 1, ExcNotImplemented());
template <int fe_degree, int n_q_points_1d, int dim>
void
do_project(const parallel::distributed::Triangulation<dim> &triangulation,
- const std::vector<const FiniteElement<dim> *> & fes,
+ const std::vector<const FiniteElement<dim> *> &fes,
const unsigned int p,
const unsigned int fe_index = 0)
{
template <typename CoefficientType>
void
-prepare_symmetric_coefficients(Table<1, CoefficientType> & coeff,
+prepare_symmetric_coefficients(Table<1, CoefficientType> &coeff,
const std::vector<CoefficientType> &coeff_1d)
{
Assert(coeff.size(0) == coeff_1d.size(), ExcInternalError());
template <typename CoefficientType>
void
-prepare_symmetric_coefficients(Table<2, CoefficientType> & coeff,
+prepare_symmetric_coefficients(Table<2, CoefficientType> &coeff,
const std::vector<CoefficientType> &coeff_1d)
{
for (unsigned int d = 0; d < 2; ++d)
template <typename CoefficientType>
void
-prepare_symmetric_coefficients(Table<3, CoefficientType> & coeff,
+prepare_symmetric_coefficients(Table<3, CoefficientType> &coeff,
const std::vector<CoefficientType> &coeff_1d)
{
for (unsigned int d = 0; d < 3; ++d)
}
// Get the location of all boundary dofs
std::vector<types::global_dof_index> face_dofs;
- const std::vector<Point<dim - 1>> & unit_support_points =
+ const std::vector<Point<dim - 1>> &unit_support_points =
fe.get_unit_face_support_points();
Quadrature<dim - 1> quadrature(unit_support_points);
FEFaceValues<dim, dim> fe_face_values(fe,
NormalProjectionManifold<2, 3> manifold_m(edge);
std::unique_ptr<Manifold<2, 3>> clone_m = manifold_m.clone();
- const auto & deref_clone_m = *clone_m;
+ const auto &deref_clone_m = *clone_m;
deallog << "typeid of NormalProjectionManifold<2, 3> is "
<< boost::core::demangle(typeid(deref_clone_m).name()) << std::endl;
}
DirectionalProjectionManifold<2, 3> manifold_m(face, Point<3>(0, 0, 1));
std::unique_ptr<Manifold<2, 3>> clone_m = manifold_m.clone();
- const auto & deref_clone_m = *clone_m;
+ const auto &deref_clone_m = *clone_m;
deallog << "typeid of DirectionalProjectionManifold<2, 3> is "
<< boost::core::demangle(typeid(deref_clone_m).name()) << std::endl;
}
NormalToMeshProjectionManifold<1, 3> manifold_m(face);
std::unique_ptr<Manifold<1, 3>> clone_m = manifold_m.clone();
- const auto & deref_clone_m = *clone_m;
+ const auto &deref_clone_m = *clone_m;
deallog << "typeid of NormalProjectionManifold<2, 3> is "
<< boost::core::demangle(typeid(deref_clone_m).name()) << std::endl;
}
counter++;
if ((counter == 4) || (counter == 5) || (counter == 6) ||
(counter == 18) || (counter == 19))
- {}
+ {
+ }
else
out << line << std::endl;
}
counter++;
if ((counter == 4) || (counter == 5) || (counter == 6) ||
(counter == 18) || (counter == 19))
- {}
+ {
+ }
else
out << line << std::endl;
}
// safety measure to not modify L or b within Lambda.
const FullMatrix<number> &L_const = L;
- const VectorType & b_const = b;
+ const VectorType &b_const = b;
const auto func = [&](const VectorType &x, VectorType &g) {
L_const.vmult(g, x);
number res = 0.5 * (g * x) - x * b_const;
// safety measure to not modify L or b within Lambda.
const FullMatrix<number> &L_const = L;
- const VectorType & b_const = b;
+ const VectorType &b_const = b;
const auto func = [&](const VectorType &x, VectorType &g) {
L_const.vmult(g, x);
number res = 0.5 * (g * x) - x * b_const;
const unsigned int print_n_iterations = 5;
unsigned int iteration = 0;
unsigned int line_search_iterations = 0;
- const auto line_min = [&](number & f,
- VectorType & x,
- VectorType & g,
+ const auto line_min = [&](number &f,
+ VectorType &x,
+ VectorType &g,
const VectorType &p) {
if (iteration <= print_n_iterations)
out << "------------------------------------------------" << std::endl
return res.first;
};
- const auto preconditioner = [](VectorType & g,
+ const auto preconditioner = [](VectorType &g,
const FiniteSizeHistory<VectorType> &s,
const FiniteSizeHistory<VectorType> &y) {
if (s.size() > 0)
return rosenbrok(x_shifted, g);
};
- const auto preconditioner = [](VectorType & g,
+ const auto preconditioner = [](VectorType &g,
const FiniteSizeHistory<VectorType> &s,
const FiniteSizeHistory<VectorType> &y) {
if (s.size() > 0)
static const SymmetricTensor<4, dim> dev_P;
};
template <int dim>
- const SymmetricTensor<2, dim>
- StandardTensors<dim>::I = unit_symmetric_tensor<dim>();
+ const SymmetricTensor<2, dim> StandardTensors<dim>::I =
+ unit_symmetric_tensor<dim>();
template <int dim>
const SymmetricTensor<4, dim> StandardTensors<dim>::IxI = outer_product(I, I);
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::II = identity_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::II =
+ identity_tensor<dim>();
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::dev_P = deviator_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::dev_P =
+ deviator_tensor<dim>();
class Time
{
public:
void
assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const;
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const;
void
copy_local_to_global_K(const PerTaskData_K &data);
void
void
assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const;
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const;
void
copy_local_to_global_rhs(const PerTaskData_RHS &data);
void
void
assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void
copy_local_to_global_sc(const PerTaskData_SC &data);
void
void
update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
- PerTaskData_UQPH & data);
+ ScratchData_UQPH &scratch,
+ PerTaskData_UQPH &data);
void
copy_local_to_global_UQPH(const PerTaskData_UQPH & /*data*/)
{}
get_error_residual(Errors &error_residual);
void
get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double>
get_error_dilation() const;
double
{
FullMatrix<double> cell_matrix;
std::vector<types::global_dof_index> local_dof_indices;
- BlockSparseMatrix<double> * tangent_matrix;
+ BlockSparseMatrix<double> *tangent_matrix;
PerTaskData_K(const unsigned int dofs_per_cell,
BlockSparseMatrix<double> &tangent_matrix)
: cell_matrix(dofs_per_cell, dofs_per_cell)
std::vector<std::vector<Tensor<2, dim>>> grad_Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_K(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, Nx(qf_cell.size(), std::vector<double>(fe_cell.dofs_per_cell))
{
Vector<double> cell_rhs;
std::vector<types::global_dof_index> local_dof_indices;
- BlockVector<double> * system_rhs;
+ BlockVector<double> *system_rhs;
PerTaskData_RHS(const unsigned int dofs_per_cell,
BlockVector<double> &system_rhs)
: cell_rhs(dofs_per_cell)
std::vector<std::vector<double>> Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_RHS(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, fe_face_values_ref(fe_cell, qf_face, uf_face)
template <int dim>
struct Solid<dim>::ScratchData_UQPH
{
- const BlockVector<double> & solution_total;
+ const BlockVector<double> &solution_total;
std::vector<Tensor<2, dim>> solution_grads_u_total;
std::vector<double> solution_values_p_total;
std::vector<double> solution_values_J_total;
FEValues<dim> fe_values_ref;
- ScratchData_UQPH(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_UQPH(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
void
Solid<dim>::update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
+ ScratchData_UQPH &scratch,
PerTaskData_UQPH & /*data*/)
{
const std::vector<std::shared_ptr<PointHistory<dim>>> lqph =
template <int dim>
void
Solid<dim>::get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler_ref.n_dofs(); ++i)
void
Solid<dim>::assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const
{
data.reset();
scratch.reset();
const SymmetricTensor<4, dim> Jc = lqph[q_point]->get_Jc();
const double d2Psi_vol_dJ2 = lqph[q_point]->get_d2Psi_vol_dJ2();
const double det_F = lqph[q_point]->get_det_F();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const std::vector<Tensor<2, dim>> &grad_Nx = scratch.grad_Nx[q_point];
void
Solid<dim>::assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const
{
data.reset();
scratch.reset();
const double J_tilde = lqph[q_point]->get_J_tilde();
const double p_tilde = lqph[q_point]->get_p_tilde();
const double dPsi_vol_dJ = lqph[q_point]->get_dPsi_vol_dJ();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const double JxW = scratch.fe_values_ref.JxW(q_point);
void
Solid<dim>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
const Vector<double> &f_u = system_rhs.block(u_dof);
const Vector<double> &f_p = system_rhs.block(p_dof);
const Vector<double> &f_J = system_rhs.block(J_dof);
- Vector<double> & d_u = newton_update.block(u_dof);
- Vector<double> & d_p = newton_update.block(p_dof);
- Vector<double> & d_J = newton_update.block(J_dof);
+ Vector<double> &d_u = newton_update.block(u_dof);
+ Vector<double> &d_p = newton_update.block(p_dof);
+ Vector<double> &d_J = newton_update.block(J_dof);
const auto K_uu =
linear_operator(tangent_matrix.block(u_dof, u_dof));
const auto K_up =
#include "../tests.h"
void
-log_entry(const ParameterHandler & prm,
+log_entry(const ParameterHandler &prm,
const std::vector<std::string> path,
- const std::string & entry)
+ const std::string &entry)
{
for (unsigned int i = 0; i < path.size(); ++i)
{
initlog();
// create a pattern and match a string
- const auto & pattern = Patterns::Tuple(";",
+ const auto &pattern = Patterns::Tuple(";",
Patterns::Integer(),
Patterns::Double(),
Patterns::Anything());
void
create_regular_particle_distribution(
Particles::ParticleHandler<dim, spacedim> &particle_handler,
- const Triangulation<dim, spacedim> & tr,
+ const Triangulation<dim, spacedim> &tr,
const unsigned int particles_per_direction = 3)
{
for (unsigned int i = 0; i < particles_per_direction; ++i)
void
create_regular_particle_distribution(
Particles::ParticleHandler<dim, spacedim> &particle_handler,
- const Triangulation<dim, spacedim> & tr,
+ const Triangulation<dim, spacedim> &tr,
const unsigned int particles_per_direction = 3)
{
for (unsigned int i = 0; i < particles_per_direction; ++i)
void
create_regular_particle_distribution(
Particles::ParticleHandler<dim, spacedim> &particle_handler,
- const Triangulation<dim, spacedim> & tr,
+ const Triangulation<dim, spacedim> &tr,
const unsigned int particles_per_direction = 3)
{
for (unsigned int i = 0; i < particles_per_direction; ++i)
Assert(!particle.has_properties(), ExcInternalError());
std::vector<char> data(particle.serialized_size_in_bytes());
- void * write_pointer = static_cast<void *>(&data.front());
+ void *write_pointer = static_cast<void *>(&data.front());
write_pointer = particle.write_particle_data_to_memory(write_pointer);
<< std::endl;
std::vector<char> data(particle.serialized_size_in_bytes());
- void * write_pointer = static_cast<void *>(&data.front());
+ void *write_pointer = static_cast<void *>(&data.front());
write_pointer = particle.write_particle_data_to_memory(write_pointer);
template <int dim, int spacedim>
void
create_regular_particle_distribution(
- Particles::ParticleHandler<dim, spacedim> & particle_handler,
+ Particles::ParticleHandler<dim, spacedim> &particle_handler,
const parallel::distributed::Triangulation<dim, spacedim> &tr,
const unsigned int particles_per_direction = 3)
{
template <int dim, int spacedim>
void
create_regular_particle_distribution(
- Particles::ParticleHandler<dim, spacedim> & particle_handler,
+ Particles::ParticleHandler<dim, spacedim> &particle_handler,
const parallel::distributed::Triangulation<dim, spacedim> &tr,
const unsigned int particles_per_direction = 3)
{
template <int dim, int spacedim>
void
insert(
- Particles::ParticleHandler<dim, spacedim> & particle_handler,
+ Particles::ParticleHandler<dim, spacedim> &particle_handler,
unsigned int n_points,
unsigned starting_id,
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bounding_boxes)
std::vector<Point<spacedim>> points(n_points);
std::vector<std::vector<double>> properties(n_points,
- {my_cpu + 1000.0,
- my_cpu + 1000.0});
+ {my_cpu + 1000.0,
+ my_cpu + 1000.0});
std::vector<types::particle_index> ids(n_points);
for (unsigned int i = 0; i < n_points; ++i)
template <int dim, int spacedim>
void
insert(
- Particles::ParticleHandler<dim, spacedim> & particle_handler,
+ Particles::ParticleHandler<dim, spacedim> &particle_handler,
unsigned int n_points,
unsigned starting_id,
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bounding_boxes)
std::vector<Point<spacedim>> points(n_points);
std::vector<std::vector<double>> properties(n_points,
- {my_cpu + 1000.0,
- my_cpu + 1000.0});
+ {my_cpu + 1000.0,
+ my_cpu + 1000.0});
std::vector<types::particle_index> ids(n_points);
for (unsigned int i = 0; i < n_points; ++i)
template <int dim, int spacedim>
void
insert(
- Particles::ParticleHandler<dim, spacedim> & particle_handler,
+ Particles::ParticleHandler<dim, spacedim> &particle_handler,
unsigned int n_points,
unsigned starting_id,
const std::vector<std::vector<BoundingBox<spacedim>>> &global_bounding_boxes)
std::vector<Point<spacedim>> points(n_points);
std::vector<std::vector<double>> properties(n_points,
- {my_cpu + 1000.0,
- my_cpu + 1000.0});
+ {my_cpu + 1000.0,
+ my_cpu + 1000.0});
std::vector<types::particle_index> ids(n_points);
for (unsigned int i = 0; i < n_points; ++i)
template <int dim, int spacedim>
void
create_regular_particle_distribution(
- Particles::ParticleHandler<dim, spacedim> & particle_handler,
+ Particles::ParticleHandler<dim, spacedim> &particle_handler,
const parallel::distributed::Triangulation<dim, spacedim> &tr,
const unsigned int particles_per_direction = 3)
{
template <int dim, int spacedim>
void
lost_particle_notification(
- const typename Particles::ParticleIterator<dim, spacedim> & particle,
+ const typename Particles::ParticleIterator<dim, spacedim> &particle,
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell)
{
deallog << "Particle <" << particle->get_id()
move_particles();
void
track_lost_particle(
- const typename Particles::ParticleIterator<dim> & particle,
+ const typename Particles::ParticleIterator<dim> &particle,
const typename Triangulation<dim>::active_cell_iterator &cell);
, time(0, 1e-4)
{
particle_handler.signals.particle_lost.connect(
- [this](const typename Particles::ParticleIterator<dim> & particle,
+ [this](const typename Particles::ParticleIterator<dim> &particle,
const typename Triangulation<dim>::active_cell_iterator &cell) {
this->track_lost_particle(particle, cell);
});
template <int dim>
void
CathodeRaySimulator<dim>::track_lost_particle(
- const typename Particles::ParticleIterator<dim> & particle,
+ const typename Particles::ParticleIterator<dim> &particle,
const typename Triangulation<dim>::active_cell_iterator &cell)
{
++n_recently_lost_particles;
virtual void
vector_value(const Point<dim> &point,
- Vector<double> & values) const override;
+ Vector<double> &values) const override;
};
template <int dim>
void
Vortex<dim>::vector_value(const Point<dim> &point,
- Vector<double> & values) const
+ Vector<double> &values) const
{
const double T = 4;
const double t = this->get_time();
unsigned int
cell_weight(
const typename parallel::distributed::Triangulation<dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status) const;
// The following two functions are responsible for outputting the simulation
unsigned int
ParticleTracking<dim>::cell_weight(
const typename parallel::distributed::Triangulation<dim>::cell_iterator
- & cell,
+ &cell,
const CellStatus status) const
{
// First, we introduce a base weight that will be assigned to every cell.
template <int dim>
double
-BoundaryValues<dim>::value(const Point<dim> & p,
+BoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
template <int dim>
void
BoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = BoundaryValues<dim>::value(p, c);
virtual void
value_list(const std::vector<Point<dim>> &p,
- std::vector<Tensor<1, dim>> & value) const override;
+ std::vector<Tensor<1, dim>> &value) const override;
};
template <int dim>
void
RightHandSide<dim>::value_list(const std::vector<Point<dim>> &vp,
- std::vector<Tensor<1, dim>> & values) const
+ std::vector<Tensor<1, dim>> &values) const
{
for (unsigned int c = 0; c < vp.size(); ++c)
{
template <class MatrixType, class PreconditionerType>
InverseMatrix<MatrixType, PreconditionerType>::InverseMatrix(
- const MatrixType & m,
+ const MatrixType &m,
const PreconditionerType &preconditioner)
: matrix(&m)
, preconditioner(&preconditioner)
template <class MatrixType, class PreconditionerType>
void
InverseMatrix<MatrixType, PreconditionerType>::vmult(
- Vector<double> & dst,
+ Vector<double> &dst,
const Vector<double> &src) const
{
SolverControl solver_control(src.size(), 1e-6 * src.l2_norm());
template <class PreconditionerType>
SchurComplement<PreconditionerType>::SchurComplement(
- const BlockSparseMatrix<double> & system_matrix,
+ const BlockSparseMatrix<double> &system_matrix,
const InverseMatrix<SparseMatrix<double>, PreconditionerType> &A_inverse)
: system_matrix(&system_matrix)
, A_inverse(&A_inverse)
template <class PreconditionerType>
void
-SchurComplement<PreconditionerType>::vmult(Vector<double> & dst,
+SchurComplement<PreconditionerType>::vmult(Vector<double> &dst,
const Vector<double> &src) const
{
system_matrix->block(0, 1).vmult(tmp1, src);
LaplaceOperator() = default;
void
- reinit(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ reinit(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const Quadrature<1> & quadrature)
+ const Quadrature<1> &quadrature)
{
typename MatrixFree<dim, Number>::AdditionalData additional_data;
additional_data.mapping_update_flags = update_gradients;
private:
void
- local_apply(const MatrixFree<dim, Number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, Number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> phi(data);
DEAL_II_HOST_DEVICE void
operator()(
CUDAWrappers::FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number>
- * fe_eval,
+ *fe_eval,
const int q_point) const
{
fe_eval->submit_gradient(fe_eval->get_gradient(q_point), q_point);
operator()(
const unsigned int cell,
const typename CUDAWrappers::MatrixFree<dim, Number>::Data *gpu_data,
- CUDAWrappers::SharedData<dim, Number> * shared_data,
- const Number * src,
- Number * dst) const
+ CUDAWrappers::SharedData<dim, Number> *shared_data,
+ const Number *src,
+ Number *dst) const
{
(void)cell; // TODO?
LaplaceOperator() = default;
void
- reinit(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ reinit(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<Number> &constraints,
- const Quadrature<1> & quadrature)
+ const Quadrature<1> &quadrature)
{
typename CUDAWrappers::MatrixFree<dim, Number>::AdditionalData
additional_data;
LaplaceOperator(){};
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<number> &constraints,
- const DoFHandler<dim> & dg_dof_handler)
+ const DoFHandler<dim> &dg_dof_handler)
{
const QGauss<1> quad(dof_handler.get_fe().degree + 1);
const QGauss<1> dg_quad(dg_dof_handler.get_fe().degree + 1);
}
void
- initialize(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+ initialize(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const AffineConstraints<number> &constraints)
{
const QGauss<1> quad(dof_handler.get_fe().degree + 1);
}
void
- vmult(VectorType & dst,
+ vmult(VectorType &dst,
const VectorType &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
}
void
- initialize_dof_vector(VectorType & vector,
+ initialize_dof_vector(VectorType &vector,
const unsigned int component = 0) const
{
data.initialize_dof_vector(vector, component);
private:
void
- local_apply(const MatrixFree<dim, number> & data,
- VectorType & dst,
- const VectorType & src,
+ local_apply(const MatrixFree<dim, number> &data,
+ VectorType &dst,
+ const VectorType &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, -1, 0, 1, number> eval(data);
template <typename Number>
void
-make_zero_mean(const std::vector<unsigned int> & constrained_dofs,
+make_zero_mean(const std::vector<unsigned int> &constrained_dofs,
LinearAlgebra::distributed::Vector<Number> &vec)
{
// set constrained entries to zero
void
initialize(const MGSmootherBase<VectorType> &coarse_smooth,
- const std::vector<unsigned int> & constrained_dofs)
+ const std::vector<unsigned int> &constrained_dofs)
{
this->coarse_smooth = &coarse_smooth;
this->constrained_dofs = &constrained_dofs;
void
operator()(const unsigned int level,
- VectorType & dst,
- const VectorType & src) const override
+ VectorType &dst,
+ const VectorType &src) const override
{
src_copy.reinit(src, true);
src_copy.copy_locally_owned_data_from(src);
private:
SmartPointer<const MGSmootherBase<VectorType>> coarse_smooth;
- const std::vector<unsigned int> * constrained_dofs;
+ const std::vector<unsigned int> *constrained_dofs;
mutable VectorType src_copy;
};
perform_time_step(const Operator &pde_operator,
const double current_time,
const double time_step,
- VectorType & solution,
- VectorType & vec_ri,
- VectorType & vec_ki) const
+ VectorType &solution,
+ VectorType &vec_ri,
+ VectorType &vec_ki) const
{
AssertDimension(ai.size() + 1, bi.size());
template <int dim>
double
- ExactSolution<dim>::value(const Point<dim> & x,
+ ExactSolution<dim>::value(const Point<dim> &x,
const unsigned int component) const
{
const double c0 = 1. / Ma;
inline DEAL_II_ALWAYS_INLINE //
Tensor<1, n_components, Number>
operator*(const Tensor<1, n_components, Tensor<1, dim, Number>> &matrix,
- const Tensor<1, dim, Number> & vector)
+ const Tensor<1, dim, Number> &vector)
{
Tensor<1, n_components, Number> result;
for (unsigned int d = 0; d < n_components; ++d)
Tensor<1, dim + 2, Number>
euler_numerical_flux(const Tensor<1, dim + 2, Number> &u_m,
const Tensor<1, dim + 2, Number> &u_p,
- const Tensor<1, dim, Number> & normal)
+ const Tensor<1, dim, Number> &normal)
{
const auto velocity_m = fluid_velocity<dim>(u_m);
const auto velocity_p = fluid_velocity<dim>(u_p);
inline DEAL_II_ALWAYS_INLINE //
Tensor<2, dim, Number>
fluid_velocity_gradient(
- const Tensor<1, dim + 2, Number> & conserved_variables,
+ const Tensor<1, dim + 2, Number> &conserved_variables,
const Tensor<1, dim + 2, Tensor<1, dim, Number>> &gradients)
{
const Number inverse_density = Number(1.) / conserved_variables[0];
inline DEAL_II_ALWAYS_INLINE //
Tensor<1, dim, Number>
fluid_temperature_gradient(
- const Tensor<1, dim + 2, Number> & conserved_variables,
+ const Tensor<1, dim + 2, Number> &conserved_variables,
const Tensor<1, dim + 2, Tensor<1, dim, Number>> &gradients)
{
const Number inverse_R = 1. / R;
template <int dim, typename VectorizedArrayType>
VectorizedArrayType
- evaluate_function(const Function<dim> & function,
+ evaluate_function(const Function<dim> &function,
const Point<dim, VectorizedArrayType> &p_vectorized,
const unsigned int component)
{
template <int dim, typename VectorizedArrayType, int n_components = dim + 2>
Tensor<1, n_components, VectorizedArrayType>
- evaluate_function(const Function<dim> & function,
+ evaluate_function(const Function<dim> &function,
const Point<dim, VectorizedArrayType> &p_vectorized)
{
AssertDimension(function.n_components, n_components);
const Number bi,
const Number ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
LinearAlgebra::distributed::Vector<Number> &solution) const;
void
const Number bi,
const Number ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
- LinearAlgebra::distributed::Vector<Number> & solution) const;
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &solution) const;
void
- project(const Function<dim> & function,
+ project(const Function<dim> &function,
LinearAlgebra::distributed::Vector<Number> &solution) const;
std::array<double, 3>
compute_errors(
- const Function<dim> & function,
+ const Function<dim> &function,
const LinearAlgebra::distributed::Vector<Number> &solution) const;
std::array<double, 2>
void
operation_on_cell(const MatrixFree<dim, Number, VectorizedArrayType> &mf,
- LinearAlgebra::distributed::Vector<Number> & dst,
- const LinearAlgebra::distributed::Vector<Number> & src,
+ LinearAlgebra::distributed::Vector<Number> &dst,
+ const LinearAlgebra::distributed::Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &range) const;
void
operation_cell(const MatrixFree<dim, Number, VectorizedArrayType> &mf,
- LinearAlgebra::distributed::Vector<Number> & dst,
- const LinearAlgebra::distributed::Vector<Number> & src,
+ LinearAlgebra::distributed::Vector<Number> &dst,
+ const LinearAlgebra::distributed::Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &range) const;
void
operation_face(const MatrixFree<dim, Number, VectorizedArrayType> &mf,
- LinearAlgebra::distributed::Vector<Number> & dst,
- const LinearAlgebra::distributed::Vector<Number> & src,
+ LinearAlgebra::distributed::Vector<Number> &dst,
+ const LinearAlgebra::distributed::Vector<Number> &src,
const std::pair<unsigned int, unsigned int> &range) const;
void
operation_boundary(
const MatrixFree<dim, Number, VectorizedArrayType> &mf,
- LinearAlgebra::distributed::Vector<Number> & dst,
- const LinearAlgebra::distributed::Vector<Number> & src,
- const std::pair<unsigned int, unsigned int> & range) const;
+ LinearAlgebra::distributed::Vector<Number> &dst,
+ const LinearAlgebra::distributed::Vector<Number> &src,
+ const std::pair<unsigned int, unsigned int> &range) const;
void
local_apply_inverse_mass_matrix(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
mutable double ai;
mutable double bi;
template <int dim, int degree, int n_points_1d>
void
NavierStokesOperator<dim, degree, n_points_1d>::reinit(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler)
{
const std::vector<const DoFHandler<dim> *> dof_handlers = {&dof_handler};
const Number bi,
const Number ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
- LinearAlgebra::distributed::Vector<Number> & solution) const
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &solution) const
{
for (auto &i : inflow_boundaries)
i.second->set_time(current_time);
void
NavierStokesOperator<dim, degree, n_points_1d>::operation_on_cell(
const MatrixFree<dim, Number, VectorizedArrayType> &data,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
- const LinearAlgebra::distributed::Vector<Number> & current_ri,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
+ const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
using FECellIntegral = FEEvaluation<dim,
degree,
const Number bi,
const Number ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
- LinearAlgebra::distributed::Vector<Number> & solution) const
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &solution) const
{
for (auto &i : inflow_boundaries)
i.second->set_time(current_time);
void
NavierStokesOperator<dim, degree, n_points_1d>::operation_cell(
const MatrixFree<dim, Number, VectorizedArrayType> &data,
- LinearAlgebra::distributed::Vector<Number> & dst,
- const LinearAlgebra::distributed::Vector<Number> & src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ LinearAlgebra::distributed::Vector<Number> &dst,
+ const LinearAlgebra::distributed::Vector<Number> &src,
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
using FECellIntegral = FEEvaluation<dim,
degree,
void
NavierStokesOperator<dim, degree, n_points_1d>::operation_face(
const MatrixFree<dim, Number, VectorizedArrayType> &data,
- LinearAlgebra::distributed::Vector<Number> & dst,
- const LinearAlgebra::distributed::Vector<Number> & src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ LinearAlgebra::distributed::Vector<Number> &dst,
+ const LinearAlgebra::distributed::Vector<Number> &src,
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
using FEFaceIntegral = FEFaceEvaluation<dim,
degree,
void
NavierStokesOperator<dim, degree, n_points_1d>::operation_boundary(
const MatrixFree<dim, Number, VectorizedArrayType> &data,
- LinearAlgebra::distributed::Vector<Number> & dst,
- const LinearAlgebra::distributed::Vector<Number> & src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ LinearAlgebra::distributed::Vector<Number> &dst,
+ const LinearAlgebra::distributed::Vector<Number> &src,
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
AssertThrow(false, ExcNotImplemented());
FEFaceEvaluation<dim,
NavierStokesOperator<dim, degree, n_points_1d>::
local_apply_inverse_mass_matrix(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree, degree + 1, dim + 2, Number> phi(data, 0, 1);
MatrixFreeOperators::CellwiseInverseMassMatrix<dim, degree, dim + 2, Number>
template <int dim, int degree, int n_points_1d>
void
NavierStokesOperator<dim, degree, n_points_1d>::project(
- const Function<dim> & function,
+ const Function<dim> &function,
LinearAlgebra::distributed::Vector<Number> &solution) const
{
FEEvaluation<dim, degree, degree + 1, dim + 2, Number, VectorizedArrayType>
template <int dim, int degree, int n_points_1d>
std::array<double, 3>
NavierStokesOperator<dim, degree, n_points_1d>::compute_errors(
- const Function<dim> & function,
+ const Function<dim> &function,
const LinearAlgebra::distributed::Vector<Number> &solution) const
{
double errors_squared[3] = {};
const Number bi,
const Number ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
LinearAlgebra::distributed::Vector<Number> &solution) const
{
ns_operator.perform_stage_face(
void
FlowProblem<dim>::Postprocessor::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
const unsigned int n_evaluation_points = inputs.solution_values.size();
template <int dim>
double
-BoundaryValues<dim>::value(const Point<dim> & p,
+BoundaryValues<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
Assert(component < this->n_components,
template <int dim>
void
BoundaryValues<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
for (unsigned int c = 0; c < this->n_components; ++c)
values(c) = BoundaryValues<dim>::value(p, c);
virtual void
value_list(const std::vector<Point<dim>> &p,
- std::vector<Tensor<1, dim>> & value) const override;
+ std::vector<Tensor<1, dim>> &value) const override;
};
template <int dim>
void
RightHandSide<dim>::value_list(const std::vector<Point<dim>> &vp,
- std::vector<Tensor<1, dim>> & values) const
+ std::vector<Tensor<1, dim>> &values) const
{
for (unsigned int c = 0; c < vp.size(); ++c)
{
template <class MatrixType, class PreconditionerType>
InverseMatrix<MatrixType, PreconditionerType>::InverseMatrix(
- const MatrixType & m,
+ const MatrixType &m,
const PreconditionerType &preconditioner)
: matrix(&m)
, preconditioner(&preconditioner)
template <class MatrixType, class PreconditionerType>
void
InverseMatrix<MatrixType, PreconditionerType>::vmult(
- Vector<double> & dst,
+ Vector<double> &dst,
const Vector<double> &src) const
{
SolverControl solver_control(src.size(), 1e-6 * src.l2_norm());
template <class PreconditionerType>
SchurComplement<PreconditionerType>::SchurComplement(
- const BlockSparseMatrix<double> & system_matrix,
+ const BlockSparseMatrix<double> &system_matrix,
const InverseMatrix<SparseMatrix<double>, PreconditionerType> &A_inverse)
: system_matrix(&system_matrix)
, A_inverse(&A_inverse)
template <class PreconditionerType>
void
-SchurComplement<PreconditionerType>::vmult(Vector<double> & dst,
+SchurComplement<PreconditionerType>::vmult(Vector<double> &dst,
const Vector<double> &src) const
{
system_matrix->block(0, 1).vmult(tmp1, src);
LaplaceOperator();
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const;
void
- vmult(LinearAlgebra::distributed::Vector<number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
private:
virtual void
apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const override;
void
- local_apply(const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ local_apply(const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_compute_diagonal(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
- const unsigned int & dummy,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
+ const unsigned int &dummy,
const std::pair<unsigned int, unsigned int> &cell_range) const;
};
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::local_apply(
- const MatrixFree<dim, number> & data,
- LinearAlgebra::distributed::Vector<number> & dst,
+ const MatrixFree<dim, number> &data,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(data);
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::apply_add(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
this->data->cell_loop(&LaplaceOperator::local_apply, this, dst, src);
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::vmult(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src) const
{
this->data->cell_loop(&LaplaceOperator::local_apply, this, dst, src, true);
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::vmult(
- LinearAlgebra::distributed::Vector<number> & dst,
+ LinearAlgebra::distributed::Vector<number> &dst,
const LinearAlgebra::distributed::Vector<number> &src,
const std::function<void(const unsigned int, const unsigned int)>
&operation_before_loop,
template <int dim, int fe_degree, typename number>
void
LaplaceOperator<dim, fe_degree, number>::local_compute_diagonal(
- const MatrixFree<dim, number> & data,
+ const MatrixFree<dim, number> &data,
LinearAlgebra::distributed::Vector<number> &dst,
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
virtual void
vector_value(const Point<dim> &point,
- Vector<double> & values) const override;
+ Vector<double> &values) const override;
};
template <int dim>
void
Vortex<dim>::vector_value(const Point<dim> &point,
- Vector<double> & values) const
+ Vector<double> &values) const
{
const double T = 4;
const double t = this->get_time();
unsigned int
ParticleTracking<dim>::cell_weight(
const typename parallel::distributed::Triangulation<dim>::cell_iterator
- & cell,
+ &cell,
const typename parallel::distributed::Triangulation<dim>::CellStatus status)
const
{
struct Data
{
Data(const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature)
+ const hp::QCollection<dim> &quadrature)
: hp_fe_values(fe,
quadrature,
update_values | update_gradients |
void
local_assemble(const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data);
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
void
LaplaceProblem<dim>::local_assemble(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data)
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
* not be the same vector.
*/
void
- vmult(dealii::PETScWrappers::VectorBase & dst,
+ vmult(dealii::PETScWrappers::VectorBase &dst,
const dealii::PETScWrappers::VectorBase &src) const;
/**
* not be the same vector.
*/
void
- Tvmult(dealii::PETScWrappers::VectorBase & dst,
+ Tvmult(dealii::PETScWrappers::VectorBase &dst,
const dealii::PETScWrappers::VectorBase &src) const;
/**
* not be the same vector.
*/
void
- vmult_add(dealii::PETScWrappers::VectorBase & dst,
+ vmult_add(dealii::PETScWrappers::VectorBase &dst,
const dealii::PETScWrappers::VectorBase &src) const;
/**
* not be the same vector.
*/
void
- Tvmult_add(dealii::PETScWrappers::VectorBase & dst,
+ Tvmult_add(dealii::PETScWrappers::VectorBase &dst,
const dealii::PETScWrappers::VectorBase &src) const;
private:
inline void
-PetscFDMatrix::vmult_add(dealii::PETScWrappers::VectorBase & dst,
+PetscFDMatrix::vmult_add(dealii::PETScWrappers::VectorBase &dst,
const dealii::PETScWrappers::VectorBase &src) const
{
for (unsigned int i = 0; i <= ny - 2; ++i)
inline void
-PetscFDMatrix::vmult(dealii::PETScWrappers::VectorBase & dst,
+PetscFDMatrix::vmult(dealii::PETScWrappers::VectorBase &dst,
const dealii::PETScWrappers::VectorBase &src) const
{
dst = 0;
inline void
-PetscFDMatrix::Tvmult(dealii::PETScWrappers::VectorBase & dst,
+PetscFDMatrix::Tvmult(dealii::PETScWrappers::VectorBase &dst,
const dealii::PETScWrappers::VectorBase &src) const
{
dst = 0;
inline void
-PetscFDMatrix::Tvmult_add(dealii::PETScWrappers::VectorBase & dst,
+PetscFDMatrix::Tvmult_add(dealii::PETScWrappers::VectorBase &dst,
const dealii::PETScWrappers::VectorBase &src) const
{
vmult_add(dst, src);
};
// Test attaching a user-defined monitoring routine
- solver.monitor = [&](const VectorType & X,
+ solver.monitor = [&](const VectorType &X,
const unsigned int step,
const real_type fval) -> void {
out << "# " << step << ": " << fval << std::endl;
// solvers can still be used in a Jacobian-free way and selected at command
// line or within user code.
solver.solve_with_jacobian = [&](const VectorType &src,
- VectorType & dst) -> void {
+ VectorType &dst) -> void {
dst(0) = Jinv(0, 0) * src(0) + Jinv(0, 1) * src(1);
dst(1) = Jinv(1, 0) * src(0) + Jinv(1, 1) * src(1);
dst.compress(VectorOperation::insert);
};
solver.solve_with_jacobian = [&](const VectorType &src,
- VectorType & dst) -> void {
+ VectorType &dst) -> void {
dst.block(0)[0] =
Jinv(0, 0) * src.block(0)[0] + Jinv(0, 1) * src.block(1)[0];
dst.block(1)[0] =
};
solver.solve_with_jacobian = [&](const VectorType &rhs,
- VectorType & sol) -> void {
+ VectorType &sol) -> void {
deallog << "Solve Jacobian" << std::endl;
if (throw_exception && testcase == 2)
bool setjac,
bool implicit,
bool user,
- std::ostream & _out)
+ std::ostream &_out)
: time_stepper(data)
, out(_out)
, kappa(_kappa)
time_stepper.implicit_function = [&](const real_type t,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res) -> void {
+ VectorType &res) -> void {
res(0) = y_dot(0) - y(1);
res(1) = y_dot(1) + kappa * kappa * y(0);
res.compress(VectorOperation::insert);
const VectorType &y,
const VectorType &y_dot,
const real_type shift,
- MatrixType & A,
- MatrixType & P) -> void {
+ MatrixType &A,
+ MatrixType &P) -> void {
P.set(0, 0, shift);
P.set(0, 1, -1);
P.set(1, 0, kappa * kappa);
{
time_stepper.explicit_jacobian = [&](const real_type t,
const VectorType &y,
- MatrixType & A,
- MatrixType & P) -> void {
+ MatrixType &A,
+ MatrixType &P) -> void {
P.set(0, 0, 0);
P.set(0, 1, 1);
P.set(1, 0, -kappa * kappa);
// Monitoring routine. Here we print diagnostic for the exact
// solution to the log file.
time_stepper.monitor = [&](const real_type t,
- const VectorType & y,
+ const VectorType &y,
const unsigned int step_number) -> void {
std::vector<real_type> exact(2);
exact[0] = std::sin(kappa * t);
//
//-----------------------------------------------------------
-//#include <deal.II/base/parameter_handler.h>
+// #include <deal.II/base/parameter_handler.h>
#include <deal.II/lac/petsc_ts.h>
#include <deal.II/lac/petsc_vector.h>
implicit_function = [&](const real_type t,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res) -> void {
+ VectorType &res) -> void {
res(0) = y_dot(0) - y(0);
res(1) = y(1) - y(0);
res.compress(VectorOperation::insert);
time_stepper.implicit_function = [&](const real_type t,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res) -> void {
+ VectorType &res) -> void {
deallog << "Evaluating implicit function at t=" << t << std::endl;
res(0) = y_dot(0) + kappa * y(0);
res.compress(VectorOperation::insert);
const VectorType &y,
const VectorType &y_dot,
const real_type shift,
- MatrixType & A,
- MatrixType & P) -> void {
+ MatrixType &A,
+ MatrixType &P) -> void {
deallog << "Evaluating implicit Jacobian at t=" << t << std::endl;
P.set(0, 0, shift + kappa);
P.compress(VectorOperation::insert);
{
time_stepper.explicit_jacobian = [&](const real_type t,
const VectorType &y,
- MatrixType & A,
- MatrixType & P) -> void {
+ MatrixType &A,
+ MatrixType &P) -> void {
deallog << "Evaluating explicit Jacobian at t=" << t << std::endl;
P.set(0, 0, -kappa);
P.compress(VectorOperation::insert);
time_stepper.implicit_function = [&](const real_type t,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res) -> void {
+ VectorType &res) -> void {
deallog << "Evaluating implicit function at t=" << t << std::endl;
if (t > last_eval_time + 0.1)
const VectorType &y,
const VectorType &y_dot,
const real_type shift,
- MatrixType & A,
- MatrixType & P) -> void {
+ MatrixType &A,
+ MatrixType &P) -> void {
deallog << "Evaluating implicit Jacobian at t=" << t << std::endl;
P.set(0, 0, shift + kappa);
P.compress(VectorOperation::insert);
{
time_stepper.explicit_jacobian = [&](const real_type t,
const VectorType &y,
- MatrixType & A,
- MatrixType & P) -> void {
+ MatrixType &A,
+ MatrixType &P) -> void {
deallog << "Evaluating explicit Jacobian at t=" << t << std::endl;
P.set(0, 0, -kappa);
P.compress(VectorOperation::insert);
const VectorType &y,
const VectorType &y_dot,
const real_type shift,
- MatrixType & A,
- MatrixType & P) -> void {
+ MatrixType &A,
+ MatrixType &P) -> void {
deallog << "Evaluating implicit Jacobian at t=" << t << std::endl;
if (throw_error)
{
};
time_stepper.solve_with_jacobian = [&](const VectorType &src,
- VectorType & dst) -> void {
+ VectorType &dst) -> void {
deallog << "Solving with Jacobian" << std::endl;
if (throw_error && testcase == 2)
{
// Identity preconditioner
preconditioner_user.vmult =
- [](PETScWrappers::VectorBase & dst,
+ [](PETScWrappers::VectorBase &dst,
const PETScWrappers::VectorBase &src) -> void { dst = src; };
check_solver_within_range(solver.solve(A, u, f, preconditioner_user),
// -1)} + \frac 12 \rho \|u\|^2$.
template <int dim>
double
- ExactSolution<dim>::value(const Point<dim> & x,
+ ExactSolution<dim>::value(const Point<dim> &x,
const unsigned int component) const
{
const double t = this->get_time();
perform_time_step(const Operator &pde_operator,
const double current_time,
const double time_step,
- VectorType & solution,
- VectorType & vec_ri,
- VectorType & vec_ki) const
+ VectorType &solution,
+ VectorType &vec_ri,
+ VectorType &vec_ki) const
{
AssertDimension(ai.size() + 1, bi.size());
inline DEAL_II_ALWAYS_INLINE //
Tensor<1, n_components, Number>
operator*(const Tensor<1, n_components, Tensor<1, dim, Number>> &matrix,
- const Tensor<1, dim, Number> & vector)
+ const Tensor<1, dim, Number> &vector)
{
Tensor<1, n_components, Number> result;
for (unsigned int d = 0; d < n_components; ++d)
Tensor<1, dim + 2, Number>
euler_numerical_flux(const Tensor<1, dim + 2, Number> &u_m,
const Tensor<1, dim + 2, Number> &u_p,
- const Tensor<1, dim, Number> & normal)
+ const Tensor<1, dim, Number> &normal)
{
const auto velocity_m = euler_velocity<dim>(u_m);
const auto velocity_p = euler_velocity<dim>(u_p);
// where all components of the solution are set.
template <int dim, typename Number>
VectorizedArray<Number>
- evaluate_function(const Function<dim> & function,
+ evaluate_function(const Function<dim> &function,
const Point<dim, VectorizedArray<Number>> &p_vectorized,
const unsigned int component)
{
template <int dim, typename Number, int n_components = dim + 2>
Tensor<1, n_components, VectorizedArray<Number>>
- evaluate_function(const Function<dim> & function,
+ evaluate_function(const Function<dim> &function,
const Point<dim, VectorizedArray<Number>> &p_vectorized)
{
AssertDimension(function.n_components, n_components);
void
apply(const double current_time,
const LinearAlgebra::distributed::Vector<Number> &src,
- LinearAlgebra::distributed::Vector<Number> & dst) const;
+ LinearAlgebra::distributed::Vector<Number> &dst) const;
void
perform_stage(const Number cur_time,
const Number factor_solution,
const Number factor_ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
- LinearAlgebra::distributed::Vector<Number> & solution,
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &solution,
LinearAlgebra::distributed::Vector<Number> &next_ri) const;
void
- project(const Function<dim> & function,
+ project(const Function<dim> &function,
LinearAlgebra::distributed::Vector<Number> &solution) const;
std::array<double, 3>
compute_errors(
- const Function<dim> & function,
+ const Function<dim> &function,
const LinearAlgebra::distributed::Vector<Number> &solution) const;
double
void
local_apply_inverse_mass_matrix(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_apply_cell(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_apply_face(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const;
+ const std::pair<unsigned int, unsigned int> &face_range) const;
void
local_apply_boundary_face(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const;
+ const std::pair<unsigned int, unsigned int> &face_range) const;
};
template <int dim, int degree, int n_points_1d>
void
EulerOperator<dim, degree, n_points_1d>::reinit(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler)
{
const std::vector<const DoFHandler<dim> *> dof_handlers = {&dof_handler};
void
EulerOperator<dim, degree, n_points_1d>::local_apply_cell(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree, n_points_1d, dim + 2, Number> phi(data);
void
EulerOperator<dim, degree, n_points_1d>::local_apply_face(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, degree, n_points_1d, dim + 2, Number> phi_m(data,
true);
void
EulerOperator<dim, degree, n_points_1d>::local_apply_boundary_face(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
FEFaceEvaluation<dim, degree, n_points_1d, dim + 2, Number> phi(data, true);
void
EulerOperator<dim, degree, n_points_1d>::local_apply_inverse_mass_matrix(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree, degree + 1, dim + 2, Number> phi(data, 0, 1);
MatrixFreeOperators::CellwiseInverseMassMatrix<dim, degree, dim + 2, Number>
EulerOperator<dim, degree, n_points_1d>::apply(
const double current_time,
const LinearAlgebra::distributed::Vector<Number> &src,
- LinearAlgebra::distributed::Vector<Number> & dst) const
+ LinearAlgebra::distributed::Vector<Number> &dst) const
{
{
TimerOutput::Scope t(timer, "apply - integrals");
const Number factor_solution,
const Number factor_ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
- LinearAlgebra::distributed::Vector<Number> & solution,
- LinearAlgebra::distributed::Vector<Number> & next_ri) const
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &solution,
+ LinearAlgebra::distributed::Vector<Number> &next_ri) const
{
{
TimerOutput::Scope t(timer, "rk_stage - integrals L_h");
template <int dim, int degree, int n_points_1d>
void
EulerOperator<dim, degree, n_points_1d>::project(
- const Function<dim> & function,
+ const Function<dim> &function,
LinearAlgebra::distributed::Vector<Number> &solution) const
{
FEEvaluation<dim, degree, degree + 1, dim + 2, Number> phi(data, 0, 1);
template <int dim, int degree, int n_points_1d>
std::array<double, 3>
EulerOperator<dim, degree, n_points_1d>::compute_errors(
- const Function<dim> & function,
+ const Function<dim> &function,
const LinearAlgebra::distributed::Vector<Number> &solution) const
{
TimerOutput::Scope t(timer, "compute errors");
void
EulerProblem<dim>::Postprocessor::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
const unsigned int n_evaluation_points = inputs.solution_values.size();
// current implementation does not directly support this vector class.
using VectorType = PETScWrappers::MPI::Vector;
- auto copy_from_petsc = [](const VectorType & src,
+ auto copy_from_petsc = [](const VectorType &src,
LinearAlgebra::distributed::Vector<Number> &dst) {
auto lr = src.local_range();
for (unsigned int i = lr.first; i < lr.second; i++)
auto copy_to_petsc =
[](const LinearAlgebra::distributed::Vector<Number> &src,
- VectorType & dst) {
+ VectorType &dst) {
auto lr = dst.local_range();
for (unsigned int i = lr.first; i < lr.second; i++)
dst[i] = src[i];
void
MinimalSurfaceProblem<dim>::compute_residual(
const VectorType &evaluation_point,
- VectorType & residual)
+ VectorType &residual)
{
deallog << " Computing residual vector " << std::endl;
const QGauss<dim> quadrature_formula(fe.degree + 1);
// Here we inform the nonlinear_solver about how to sample the
// residual of our nonlinear equations.
nonlinear_solver.residual = [&](const VectorType &evaluation_point,
- VectorType & residual) {
+ VectorType &residual) {
compute_residual(evaluation_point, residual);
return 0;
};
template <class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
void
-check_solve(SOLVER & solver,
- const MATRIX & A,
- VECTOR & u,
- VECTOR & f,
+check_solve(SOLVER &solver,
+ const MATRIX &A,
+ VECTOR &u,
+ VECTOR &f,
const PRECONDITION &P)
{
deallog << "Solver type: " << typeid(solver).name() << std::endl;
template <class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
void
-check_solve(SOLVER & solver,
- const MATRIX & A,
- VECTOR & u,
- VECTOR & f,
+check_solve(SOLVER &solver,
+ const MATRIX &A,
+ VECTOR &u,
+ VECTOR &f,
const PRECONDITION &P)
{
deallog << "Solver type: " << typeid(solver).name() << std::endl;
template <class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
void
-check_solve(SOLVER & solver,
- const MATRIX & A,
- VECTOR & u,
- VECTOR & f,
+check_solve(SOLVER &solver,
+ const MATRIX &A,
+ VECTOR &u,
+ VECTOR &f,
const PRECONDITION &P)
{
deallog << "Solver type: " << typeid(solver).name() << std::endl;
vector_value(const Point<dim> &p, Vector<double> &values) const;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const;
+ std::vector<Vector<double>> &value_list) const;
};
template <int dim>
BodyForce<dim>::BodyForce()
void
BodyForce<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
const unsigned int n_points = points.size();
Assert(value_list.size() == n_points,
vector_value(const Point<dim> &p, Vector<double> &values) const;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const;
+ std::vector<Vector<double>> &value_list) const;
private:
const double velocity;
void
IncrementalBoundaryValues<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
const unsigned int n_points = points.size();
Assert(value_list.size() == n_points,
vector_value(const Point<dim> &p, Vector<double> &values) const;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const;
+ std::vector<Vector<double>> &value_list) const;
};
template <int dim>
BodyForce<dim>::BodyForce()
void
BodyForce<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
const unsigned int n_points = points.size();
Assert(value_list.size() == n_points,
vector_value(const Point<dim> &p, Vector<double> &values) const;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const;
+ std::vector<Vector<double>> &value_list) const;
private:
const double velocity;
void
IncrementalBoundaryValues<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
const unsigned int n_points = points.size();
Assert(value_list.size() == n_points,
static const SymmetricTensor<4, dim> dev_P;
};
template <int dim>
- const SymmetricTensor<2, dim>
- StandardTensors<dim>::I = unit_symmetric_tensor<dim>();
+ const SymmetricTensor<2, dim> StandardTensors<dim>::I =
+ unit_symmetric_tensor<dim>();
template <int dim>
const SymmetricTensor<4, dim> StandardTensors<dim>::IxI = outer_product(I, I);
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::II = identity_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::II =
+ identity_tensor<dim>();
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::dev_P = deviator_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::dev_P =
+ deviator_tensor<dim>();
class Time
{
public:
void
assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const;
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const;
void
copy_local_to_global_K(const PerTaskData_K &data);
void
void
assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const;
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const;
void
copy_local_to_global_rhs(const PerTaskData_RHS &data);
void
void
assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void
copy_local_to_global_sc(const PerTaskData_SC &data);
void
void
update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
- PerTaskData_UQPH & data);
+ ScratchData_UQPH &scratch,
+ PerTaskData_UQPH &data);
void
copy_local_to_global_UQPH(const PerTaskData_UQPH & /*data*/)
{}
get_error_residual(Errors &error_residual);
void
get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double>
get_error_dilation() const;
double
std::vector<std::vector<Tensor<2, dim>>> grad_Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_K(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, Nx(qf_cell.size(), std::vector<double>(fe_cell.dofs_per_cell))
std::vector<std::vector<double>> Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_RHS(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, fe_face_values_ref(fe_cell, qf_face, uf_face)
template <int dim>
struct Solid<dim>::ScratchData_UQPH
{
- const BlockVector<double> & solution_total;
+ const BlockVector<double> &solution_total;
std::vector<Tensor<2, dim>> solution_grads_u_total;
std::vector<double> solution_values_p_total;
std::vector<double> solution_values_J_total;
FEValues<dim> fe_values_ref;
- ScratchData_UQPH(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_UQPH(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
void
Solid<dim>::update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
+ ScratchData_UQPH &scratch,
PerTaskData_UQPH & /*data*/)
{
const std::vector<std::shared_ptr<PointHistory<dim>>> lqph =
template <int dim>
void
Solid<dim>::get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler_ref.n_dofs(); ++i)
void
Solid<dim>::assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const
{
data.reset();
scratch.reset();
const SymmetricTensor<4, dim> Jc = lqph[q_point]->get_Jc();
const double d2Psi_vol_dJ2 = lqph[q_point]->get_d2Psi_vol_dJ2();
const double det_F = lqph[q_point]->get_det_F();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const std::vector<Tensor<2, dim>> &grad_Nx = scratch.grad_Nx[q_point];
void
Solid<dim>::assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const
{
data.reset();
scratch.reset();
const double J_tilde = lqph[q_point]->get_J_tilde();
const double p_tilde = lqph[q_point]->get_p_tilde();
const double dPsi_vol_dJ = lqph[q_point]->get_dPsi_vol_dJ();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const double JxW = scratch.fe_values_ref.JxW(q_point);
void
Solid<dim>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
const Vector<double> &f_u = system_rhs.block(u_dof);
const Vector<double> &f_p = system_rhs.block(p_dof);
const Vector<double> &f_J = system_rhs.block(J_dof);
- Vector<double> & d_u = newton_update.block(u_dof);
- Vector<double> & d_p = newton_update.block(p_dof);
- Vector<double> & d_J = newton_update.block(J_dof);
+ Vector<double> &d_u = newton_update.block(u_dof);
+ Vector<double> &d_p = newton_update.block(p_dof);
+ Vector<double> &d_J = newton_update.block(J_dof);
const auto K_uu =
linear_operator(tangent_matrix.block(u_dof, u_dof));
const auto K_up =
void
assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const;
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const;
void
copy_local_to_global_K(const PerTaskData_K &data);
void
void
assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const;
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const;
void
copy_local_to_global_rhs(const PerTaskData_RHS &data);
void
void
assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void
copy_local_to_global_sc(const PerTaskData_SC &data);
void
void
update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
- PerTaskData_UQPH & data);
+ ScratchData_UQPH &scratch,
+ PerTaskData_UQPH &data);
void
copy_local_to_global_UQPH(const PerTaskData_UQPH & /*data*/)
{}
get_error_residual(Errors &error_residual);
void
get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double>
get_error_dilation() const;
double
std::vector<std::vector<Tensor<2, dim>>> grad_Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_K(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, Nx(qf_cell.size(), std::vector<double>(fe_cell.dofs_per_cell))
std::vector<std::vector<double>> Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_RHS(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, fe_face_values_ref(fe_cell, qf_face, uf_face)
template <int dim>
struct Solid<dim>::ScratchData_UQPH
{
- const BlockVector<double> & solution_total;
+ const BlockVector<double> &solution_total;
std::vector<Tensor<2, dim>> solution_grads_u_total;
std::vector<double> solution_values_p_total;
std::vector<double> solution_values_J_total;
FEValues<dim> fe_values_ref;
- ScratchData_UQPH(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_UQPH(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
void
Solid<dim>::update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
+ ScratchData_UQPH &scratch,
PerTaskData_UQPH & /*data*/)
{
const std::vector<std::shared_ptr<PointHistory<dim>>> lqph =
template <int dim>
void
Solid<dim>::get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler_ref.n_dofs(); ++i)
void
Solid<dim>::assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const
{
data.reset();
scratch.reset();
const SymmetricTensor<4, dim> Jc = lqph[q_point]->get_Jc();
const double d2Psi_vol_dJ2 = lqph[q_point]->get_d2Psi_vol_dJ2();
const double det_F = lqph[q_point]->get_det_F();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const std::vector<Tensor<2, dim>> &grad_Nx = scratch.grad_Nx[q_point];
void
Solid<dim>::assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const
{
data.reset();
scratch.reset();
const double J_tilde = lqph[q_point]->get_J_tilde();
const double p_tilde = lqph[q_point]->get_p_tilde();
const double dPsi_vol_dJ = lqph[q_point]->get_dPsi_vol_dJ();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const double JxW = scratch.fe_values_ref.JxW(q_point);
void
Solid<dim>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
const Vector<double> &f_u = system_rhs.block(u_dof);
const Vector<double> &f_p = system_rhs.block(p_dof);
const Vector<double> &f_J = system_rhs.block(J_dof);
- Vector<double> & d_u = newton_update.block(u_dof);
- Vector<double> & d_p = newton_update.block(p_dof);
- Vector<double> & d_J = newton_update.block(J_dof);
+ Vector<double> &d_u = newton_update.block(u_dof);
+ Vector<double> &d_p = newton_update.block(p_dof);
+ Vector<double> &d_J = newton_update.block(J_dof);
const auto K_uu =
linear_operator(tangent_matrix.block(u_dof, u_dof));
const auto K_up =
void
assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const;
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const;
void
copy_local_to_global_K(const PerTaskData_K &data);
void
void
assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const;
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const;
void
copy_local_to_global_rhs(const PerTaskData_RHS &data);
void
void
assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void
copy_local_to_global_sc(const PerTaskData_SC &data);
void
void
update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
- PerTaskData_UQPH & data);
+ ScratchData_UQPH &scratch,
+ PerTaskData_UQPH &data);
void
copy_local_to_global_UQPH(const PerTaskData_UQPH & /*data*/)
{}
get_error_residual(Errors &error_residual);
void
get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double>
get_error_dilation() const;
double
std::vector<std::vector<Tensor<2, dim>>> grad_Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_K(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, Nx(qf_cell.size(), std::vector<double>(fe_cell.dofs_per_cell))
std::vector<std::vector<double>> Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_RHS(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, fe_face_values_ref(fe_cell, qf_face, uf_face)
template <int dim>
struct Solid<dim>::ScratchData_UQPH
{
- const BlockVector<double> & solution_total;
+ const BlockVector<double> &solution_total;
std::vector<Tensor<2, dim>> solution_grads_u_total;
std::vector<double> solution_values_p_total;
std::vector<double> solution_values_J_total;
FEValues<dim> fe_values_ref;
- ScratchData_UQPH(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_UQPH(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
void
Solid<dim>::update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
+ ScratchData_UQPH &scratch,
PerTaskData_UQPH & /*data*/)
{
const std::vector<std::shared_ptr<PointHistory<dim>>> lqph =
template <int dim>
void
Solid<dim>::get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler_ref.n_dofs(); ++i)
void
Solid<dim>::assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const
{
data.reset();
scratch.reset();
const SymmetricTensor<4, dim> Jc = lqph[q_point]->get_Jc();
const double d2Psi_vol_dJ2 = lqph[q_point]->get_d2Psi_vol_dJ2();
const double det_F = lqph[q_point]->get_det_F();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const std::vector<Tensor<2, dim>> &grad_Nx = scratch.grad_Nx[q_point];
void
Solid<dim>::assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const
{
data.reset();
scratch.reset();
const double J_tilde = lqph[q_point]->get_J_tilde();
const double p_tilde = lqph[q_point]->get_p_tilde();
const double dPsi_vol_dJ = lqph[q_point]->get_dPsi_vol_dJ();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const double JxW = scratch.fe_values_ref.JxW(q_point);
void
Solid<dim>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
const Vector<double> &f_u = system_rhs.block(u_dof);
const Vector<double> &f_p = system_rhs.block(p_dof);
const Vector<double> &f_J = system_rhs.block(J_dof);
- Vector<double> & d_u = newton_update.block(u_dof);
- Vector<double> & d_p = newton_update.block(p_dof);
- Vector<double> & d_J = newton_update.block(J_dof);
+ Vector<double> &d_u = newton_update.block(u_dof);
+ Vector<double> &d_p = newton_update.block(p_dof);
+ Vector<double> &d_J = newton_update.block(J_dof);
const auto K_uu =
linear_operator(tangent_matrix.block(u_dof, u_dof));
const auto K_up =
static const SymmetricTensor<4, dim> dev_P;
};
template <int dim>
- const SymmetricTensor<2, dim>
- StandardTensors<dim>::I = unit_symmetric_tensor<dim>();
+ const SymmetricTensor<2, dim> StandardTensors<dim>::I =
+ unit_symmetric_tensor<dim>();
template <int dim>
const SymmetricTensor<4, dim> StandardTensors<dim>::IxI = outer_product(I, I);
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::II = identity_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::II =
+ identity_tensor<dim>();
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::dev_P = deviator_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::dev_P =
+ deviator_tensor<dim>();
class Time
{
public:
void
assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const;
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const;
void
copy_local_to_global_K(const PerTaskData_K &data);
void
void
assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const;
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const;
void
copy_local_to_global_rhs(const PerTaskData_RHS &data);
void
void
assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void
copy_local_to_global_sc(const PerTaskData_SC &data);
void
void
update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
- PerTaskData_UQPH & data);
+ ScratchData_UQPH &scratch,
+ PerTaskData_UQPH &data);
void
copy_local_to_global_UQPH(const PerTaskData_UQPH & /*data*/)
{}
get_error_residual(Errors &error_residual);
void
get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double>
get_error_dilation() const;
double
std::vector<std::vector<Tensor<2, dim>>> grad_Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_K(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, Nx(qf_cell.size(), std::vector<double>(fe_cell.dofs_per_cell))
std::vector<std::vector<double>> Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_RHS(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, fe_face_values_ref(fe_cell, qf_face, uf_face)
template <int dim>
struct Solid<dim>::ScratchData_UQPH
{
- const BlockVector<double> & solution_total;
+ const BlockVector<double> &solution_total;
std::vector<Tensor<2, dim>> solution_grads_u_total;
std::vector<double> solution_values_p_total;
std::vector<double> solution_values_J_total;
FEValues<dim> fe_values_ref;
- ScratchData_UQPH(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_UQPH(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
void
Solid<dim>::update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
+ ScratchData_UQPH &scratch,
PerTaskData_UQPH & /*data*/)
{
const std::vector<std::shared_ptr<PointHistory<dim>>> lqph =
template <int dim>
void
Solid<dim>::get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler_ref.n_dofs(); ++i)
void
Solid<dim>::assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const
{
data.reset();
scratch.reset();
const SymmetricTensor<4, dim> Jc = lqph[q_point]->get_Jc();
const double d2Psi_vol_dJ2 = lqph[q_point]->get_d2Psi_vol_dJ2();
const double det_F = lqph[q_point]->get_det_F();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const std::vector<Tensor<2, dim>> &grad_Nx = scratch.grad_Nx[q_point];
void
Solid<dim>::assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const
{
data.reset();
scratch.reset();
const double J_tilde = lqph[q_point]->get_J_tilde();
const double p_tilde = lqph[q_point]->get_p_tilde();
const double dPsi_vol_dJ = lqph[q_point]->get_dPsi_vol_dJ();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const double JxW = scratch.fe_values_ref.JxW(q_point);
void
Solid<dim>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
const Vector<double> &f_u = system_rhs.block(u_dof);
const Vector<double> &f_p = system_rhs.block(p_dof);
const Vector<double> &f_J = system_rhs.block(J_dof);
- Vector<double> & d_u = newton_update.block(u_dof);
- Vector<double> & d_p = newton_update.block(p_dof);
- Vector<double> & d_J = newton_update.block(J_dof);
+ Vector<double> &d_u = newton_update.block(u_dof);
+ Vector<double> &d_p = newton_update.block(p_dof);
+ Vector<double> &d_J = newton_update.block(J_dof);
const auto K_uu =
linear_operator(tangent_matrix.block(u_dof, u_dof));
const auto K_up =
const Tensor<1, 3> u = axis / axis.norm(); // Ensure unit vector
const Tensor<2, 3> u_dyad_u = outer_product(u, u);
const double u_skew_array[3][3] = {{0.0, -u[2], u[1]},
- {u[2], 0.0, -u[0]},
- {-u[1], u[0], 0.0}};
+ {u[2], 0.0, -u[0]},
+ {-u[1], u[0], 0.0}};
const Tensor<2, 3> R_rodrigues =
u_dyad_u +
const unsigned int n = 10;
std::size_t tape_stats[STAT_SIZE];
- double * xp = new double[n];
+ double *xp = new double[n];
double yp = 0.0;
adouble *x = new adouble[n];
adouble y = 1.0;
std::array<double, n> host_y{};
// Copy input data to device.
- double * device_x;
- double * device_y;
+ double *device_x;
+ double *device_y;
cudaError_t cuda_error = cudaMalloc(&device_x, n * sizeof(double));
AssertCuda(cuda_error);
cuda_error = cudaMalloc(&device_y, n * sizeof(double));
time_stepper.residual = [&](const double /*t*/,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res) {
+ VectorType &res) {
res = y_dot;
A.vmult_add(res, y);
};
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
void
do_test(const bool enforce_unique_map,
const std::vector<Point<dim>> &evaluation_points,
- const std::pair<bool, bool> & expected_result)
+ const std::pair<bool, bool> &expected_result)
{
parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
GridGenerator::subdivided_hyper_rectangle(tria, {2, 1}, {0, 0}, {2, 1});
template <int dim, int spacedim, typename VectorType>
void
get_position_vector(const DoFHandler<dim, spacedim> &dof_handler_dim,
- VectorType & euler_coordinates_vector,
+ VectorType &euler_coordinates_vector,
const Mapping<dim, spacedim> &mapping)
{
FEValues<dim, spacedim> fe_eval(
template <int dim, int spacedim, typename VectorType>
void
-compute_normal(const Mapping<dim, spacedim> & mapping,
+compute_normal(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler_dim,
- VectorType & normal_vector)
+ VectorType &normal_vector)
{
FEValues<dim, spacedim> fe_eval_dim(
mapping,
template <int dim, int spacedim, typename VectorType>
void
-compute_curvature(const Mapping<dim, spacedim> & mapping,
+compute_curvature(const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim, spacedim> &dof_handler_dim,
const DoFHandler<dim, spacedim> &dof_handler,
const Quadrature<dim> quadrature,
- const VectorType & normal_vector,
- VectorType & curvature_vector)
+ const VectorType &normal_vector,
+ VectorType &curvature_vector)
{
FEValues<dim, spacedim> fe_eval(mapping,
dof_handler.get_fe(),
template <int dim, int spacedim, typename VectorType>
void
compute_force_vector_sharp_interface(
- const Mapping<dim, spacedim> & surface_mapping,
+ const Mapping<dim, spacedim> &surface_mapping,
const DoFHandler<dim, spacedim> &surface_dofhandler,
const DoFHandler<dim, spacedim> &surface_dofhandler_dim,
- const Quadrature<dim> & surface_quadrature,
- const Mapping<spacedim> & mapping,
- const DoFHandler<spacedim> & dof_handler,
+ const Quadrature<dim> &surface_quadrature,
+ const Mapping<spacedim> &mapping,
+ const DoFHandler<spacedim> &dof_handler,
const double surface_tension,
- const VectorType & normal_vector,
- const VectorType & curvature_vector,
- VectorType & force_vector)
+ const VectorType &normal_vector,
+ const VectorType &curvature_vector,
+ VectorType &force_vector)
{
using T = Tensor<1, spacedim, double>;
template <int dim, int spacedim, typename VectorType>
void
get_position_vector(const DoFHandler<dim, spacedim> &dof_handler_dim,
- VectorType & euler_coordinates_vector,
+ VectorType &euler_coordinates_vector,
const Mapping<dim, spacedim> &mapping)
{
FEValues<dim, spacedim> fe_eval(
void
compute_force_vector_sharp_interface(
const Triangulation<dim, spacedim> &surface_mesh,
- const Mapping<dim, spacedim> & surface_mapping,
- const Quadrature<dim> & surface_quadrature,
- const Mapping<spacedim> & mapping,
- const DoFHandler<spacedim> & dof_handler,
- const DoFHandler<spacedim> & dof_handler_dim,
+ const Mapping<dim, spacedim> &surface_mapping,
+ const Quadrature<dim> &surface_quadrature,
+ const Mapping<spacedim> &mapping,
+ const DoFHandler<spacedim> &dof_handler,
+ const DoFHandler<spacedim> &dof_handler_dim,
const double surface_tension,
- const VectorType & normal_solution,
- const VectorType & curvature_solution,
- VectorType & force_vector)
+ const VectorType &normal_solution,
+ const VectorType &curvature_solution,
+ VectorType &force_vector)
{
using T = double;
template <int dim, int spacedim, typename VectorType>
void
get_position_vector(const DoFHandler<dim, spacedim> &dof_handler_dim,
- VectorType & euler_coordinates_vector,
+ VectorType &euler_coordinates_vector,
const Mapping<dim, spacedim> &mapping)
{
FEValues<dim, spacedim> fe_eval(
template <int dim, int spacedim, typename VectorType>
void
test_1(const Triangulation<dim, spacedim> &surface_mesh,
- const Mapping<dim, spacedim> & surface_mapping,
- const Quadrature<dim> & surface_quadrature,
- const Mapping<spacedim> & mapping,
- const DoFHandler<spacedim> & dof_handler_dim,
- const VectorType & normal_solution)
+ const Mapping<dim, spacedim> &surface_mapping,
+ const Quadrature<dim> &surface_quadrature,
+ const Mapping<spacedim> &mapping,
+ const DoFHandler<spacedim> &dof_handler_dim,
+ const VectorType &normal_solution)
{
using T = Point<spacedim>;
template <int dim, int spacedim, typename VectorType>
void
test_2(const Triangulation<dim, spacedim> &surface_mesh,
- const Mapping<dim, spacedim> & surface_mapping,
- const Quadrature<dim> & surface_quadrature,
- const Mapping<spacedim> & mapping,
- const DoFHandler<spacedim> & dof_handler_dim,
- const VectorType & normal_solution)
+ const Mapping<dim, spacedim> &surface_mapping,
+ const Quadrature<dim> &surface_quadrature,
+ const Mapping<spacedim> &mapping,
+ const DoFHandler<spacedim> &dof_handler_dim,
+ const VectorType &normal_solution)
{
using T = Point<spacedim>;
template <int dim>
double
-displacement(const Point<dim> & point,
+displacement(const Point<dim> &point,
const unsigned int component,
const double factor)
{
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
get_global_bboxes(const Triangulation<dim> &tria,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const unsigned int rtree_level = 0)
{
std::vector<dealii::BoundingBox<dim>> local_boxes;
template <int dim>
void
-print(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+print(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const LinearAlgebra::distributed::Vector<double> &result,
const unsigned int counter)
{
template <int dim>
void
-print(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+print(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const LinearAlgebra::distributed::Vector<double> &result,
const unsigned int counter)
{
public:
PoissonProblem(const Triangulation<dim> &tria,
const unsigned int id,
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
- const Quadrature<dim> & quad)
+ const Quadrature<dim> &quad)
: id(id)
, mapping(mapping)
, fe(fe)
}
void
- solve(const DoFHandler<dim> & dof_handler_other,
+ solve(const DoFHandler<dim> &dof_handler_other,
const LinearAlgebra::distributed::Vector<double> &solution_other,
- const Mapping<dim> & mapping_other)
+ const Mapping<dim> &mapping_other)
{
AffineConstraints<double> constraints;
{
public:
const unsigned int id;
- const Mapping<dim> & mapping;
- const FiniteElement<dim> & fe;
- const Quadrature<dim> & quad;
+ const Mapping<dim> &mapping;
+ const FiniteElement<dim> &fe;
+ const Quadrature<dim> &quad;
DoFHandler<dim> dof_handler;
std::shared_ptr<const Utilities::MPI::Partitioner> partitioner;
LinearAlgebra::distributed::Vector<double> solution;
template <int dim>
void
-print(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+print(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const LinearAlgebra::distributed::Vector<double> &result,
const unsigned int counter)
{
template <int dim>
void
-print(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+print(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const LinearAlgebra::distributed::Vector<double> &result,
const unsigned int counter)
{
template <int dim, int spacedim>
void
-print(const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof_handler,
+print(const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof_handler,
const LinearAlgebra::distributed::Vector<double> &result,
const unsigned int counter)
{
template <int dim>
void
-print(const Mapping<dim> & mapping,
- const DoFHandler<dim> & dof_handler,
+print(const Mapping<dim> &mapping,
+ const DoFHandler<dim> &dof_handler,
const LinearAlgebra::distributed::Vector<double> &result,
const unsigned int counter)
{
#include "../tests.h"
-//# include <Sacado.hpp>
+// # include <Sacado.hpp>
#include <complex>
#include <fstream>
df(const double &x,
const double &y,
const double &z,
- double & df_dx,
- double & df_dy)
+ double &df_dx,
+ double &df_dy)
{
df_dx = z * (1.0 + y);
df_dy = z * (z + x);
df(const double &x,
const double &y,
const double &z,
- double & df_dx,
- double & df_dy)
+ double &df_dx,
+ double &df_dy)
{
df_dx = z * (1.0 + y);
df_dy = z * (z + x);
df(const double &x,
const double &y,
const double &z,
- double & df_dx,
- double & df_dy)
+ double &df_dx,
+ double &df_dy)
{
df_dx = z * (1.0 + y);
df_dy = z * (z + x);
dg(const double &x,
const double &y,
const double &z,
- double & dg_dx,
- double & dg_dy)
+ double &dg_dx,
+ double &dg_dy)
{
dg_dx = z * std::cos(x * z) * std::cos(y / z);
dg_dy = -(1.0 / z) * std::sin(x * z) * std::sin(y / z);
dh(const double &x,
const double &y,
const double &z,
- double & dh_dx,
- double & dh_dy)
+ double &dh_dx,
+ double &dh_dy)
{
dh_dx = y * z;
dh_dy = x * z;
df(const double &x,
const double &y,
const double &z,
- double & df_dx,
- double & df_dy)
+ double &df_dx,
+ double &df_dy)
{
df_dx = z * (3.0 * x * x + 0.5 * y * y);
df_dy = z * (2.0 * z * y + x * y);
d2f(const double &x,
const double &y,
const double &z,
- double & d2f_dx_dx,
- double & d2f_dy_dy,
- double & d2f_dy_dx)
+ double &d2f_dx_dx,
+ double &d2f_dy_dy,
+ double &d2f_dy_dx)
{
d2f_dx_dx = z * (6.0 * x);
d2f_dy_dx = z * y;
df(const double &x,
const double &y,
const double &z,
- double & df_dx,
- double & df_dy)
+ double &df_dx,
+ double &df_dy)
{
df_dx = z * (3.0 * x * x + 0.5 * y * y);
df_dy = z * (2.0 * z * y + x * y);
d2f(const double &x,
const double &y,
const double &z,
- double & d2f_dx_dx,
- double & d2f_dy_dy,
- double & d2f_dy_dx)
+ double &d2f_dx_dx,
+ double &d2f_dy_dy,
+ double &d2f_dy_dx)
{
d2f_dx_dx = z * (6.0 * x);
d2f_dy_dx = z * y;
df(const double &x,
const double &y,
const double &z,
- double & df_dx,
- double & df_dy)
+ double &df_dx,
+ double &df_dy)
{
df_dx = z * (3.0 * x * x + 0.5 * y * y);
df_dy = z * (2.0 * z * y + x * y);
dg(const double &x,
const double &y,
const double &z,
- double & dg_dx,
- double & dg_dy)
+ double &dg_dx,
+ double &dg_dy)
{
dg_dx = z * std::cos(x * z) * std::cos(y / z);
dg_dy = -(1.0 / z) * std::sin(x * z) * std::sin(y / z);
dh(const double &x,
const double &y,
const double &z,
- double & dh_dx,
- double & dh_dy)
+ double &dh_dx,
+ double &dh_dy)
{
dh_dx = 2 * x * y * y * z;
dh_dy = 2 * x * x * y * z;
d2f(const double &x,
const double &y,
const double &z,
- double & d2f_dx_dx,
- double & d2f_dy_dy,
- double & d2f_dy_dx)
+ double &d2f_dx_dx,
+ double &d2f_dy_dy,
+ double &d2f_dy_dx)
{
d2f_dx_dx = z * (6.0 * x);
d2f_dy_dx = z * y;
d2g(const double &x,
const double &y,
const double &z,
- double & d2g_dx_dx,
- double & d2g_dy_dy,
- double & d2g_dy_dx)
+ double &d2g_dx_dx,
+ double &d2g_dy_dy,
+ double &d2g_dy_dx)
{
d2g_dx_dx = -z * z * std::sin(x * z) * std::cos(y / z);
d2g_dy_dx = -std::cos(x * z) * std::sin(y / z);
d2h(const double &x,
const double &y,
const double &z,
- double & d2h_dx_dx,
- double & d2h_dy_dy,
- double & d2h_dy_dx)
+ double &d2h_dx_dx,
+ double &d2h_dy_dy,
+ double &d2h_dy_dx)
{
d2h_dx_dx = 2 * y * y * z;
d2h_dy_dx = 4 * x * y * z;
t2[i] = 3. * b - i;
}
const Tensor<1, 2, SSdouble> t3 = t2;
- t1 * t2;
+ t1 *t2;
t2 += a * t1;
template <int dim, int spacedim>
void
create_regular_particle_distribution(
- Particles::ParticleHandler<dim, spacedim> & particle_handler,
+ Particles::ParticleHandler<dim, spacedim> &particle_handler,
const parallel::distributed::Triangulation<dim, spacedim> &tr,
const unsigned int particles_per_direction = 3)
{
template <int dim, int spacedim>
void
create_regular_particle_distribution(
- Particles::ParticleHandler<dim, spacedim> & particle_handler,
+ Particles::ParticleHandler<dim, spacedim> &particle_handler,
const parallel::distributed::Triangulation<dim, spacedim> &tr,
const unsigned int particles_per_direction = 3)
{
void
create_regular_particle_distribution(
Particles::ParticleHandler<dim, spacedim> &particle_handler,
- const Triangulation<dim, spacedim> & tr,
+ const Triangulation<dim, spacedim> &tr,
const unsigned int particles_per_direction = 3)
{
for (unsigned int i = 0; i < particles_per_direction; ++i)
test()
{
{
- C * p = new C();
+ C *p = new C();
std::pair<C *, C *> pair_1(p, p);
std::pair<C *, C *> pair_2;
test()
{
{
- C * c = new C();
+ C *c = new C();
std::pair<P, P> pair_1, pair_2;
pair_1.first.c = c;
pair_1.second.c = c;
template <int dim, int spacedim>
void
write_mesh(const parallel::shared::Triangulation<dim, spacedim> &tria,
- const char * filename_)
+ const char *filename_)
{
DataOut<dim> data_out;
data_out.attach_triangulation(tria);
template <int dim, int spacedim>
void
write_mesh(const parallel::shared::Triangulation<dim, spacedim> &tria,
- const char * filename_)
+ const char *filename_)
{
DataOut<dim> data_out;
data_out.attach_triangulation(tria);
template <int dim>
void
-compare_meshes(parallel::shared::Triangulation<dim> & shared_tria,
+compare_meshes(parallel::shared::Triangulation<dim> &shared_tria,
parallel::distributed::Triangulation<dim> &p4est_tria)
{
std::map<CellId, unsigned int> shared_map;
template <int dim>
void
-compare_meshes(parallel::shared::Triangulation<dim> & shared_tria,
+compare_meshes(parallel::shared::Triangulation<dim> &shared_tria,
parallel::distributed::Triangulation<dim> &p4est_tria)
{
AssertThrow(shared_tria.n_locally_owned_active_cells() ==
const auto tet4 = BarycentricPolynomials<3>::get_fe_p_basis(1);
FE_SimplexP<3> fe(1);
- const auto & points = fe.get_unit_support_points();
+ const auto &points = fe.get_unit_support_points();
for (unsigned int i = 0; i < 4; ++i)
{
Assert(points.size() == 4, ExcInternalError());
const auto tet10 = BarycentricPolynomials<3>::get_fe_p_basis(2);
FE_SimplexP<3> fe(2);
- const auto & points = fe.get_unit_support_points();
+ const auto &points = fe.get_unit_support_points();
for (unsigned int i = 0; i < 10; ++i)
{
Assert(points.size() == 10, ExcInternalError());
template <int dim, int spacedim>
void
process(const std::vector<Point<spacedim>> &vertices,
- const std::vector<CellData<dim>> & cells)
+ const std::vector<CellData<dim>> &cells)
{
Triangulation<dim, spacedim> tria;
tria.create_triangulation(vertices, cells, SubCellData());
template <int dim, int spacedim = dim>
void
-test(const FiniteElement<dim, spacedim> & fe,
+test(const FiniteElement<dim, spacedim> &fe,
const std::function<void(Triangulation<dim, spacedim> &)> &fu)
{
Triangulation<dim, spacedim> tria;
template <int dim, int spacedim = dim>
void
test(const Triangulation<dim, spacedim> &tria,
- const Mapping<dim, spacedim> & mapping,
- const Quadrature<dim - 1> & face_quadrature)
+ const Mapping<dim, spacedim> &mapping,
+ const Quadrature<dim - 1> &face_quadrature)
{
Assert(tria.get_reference_cells().size() == 1, ExcNotImplemented());
const ReferenceCell reference_cell = tria.get_reference_cells().front();
template <int dim>
void
set_active_fe_indices(const std::vector<unsigned int> &fe_indices,
- DoFHandler<dim> & dofh)
+ DoFHandler<dim> &dofh)
{
AssertDimension(fe_indices.size(), dofh.get_triangulation().n_cells(0));
for (const auto &cell : dofh.active_cell_iterators())
{
- const auto & fe = cell->get_fe();
+ const auto &fe = cell->get_fe();
const unsigned int fe_index = cell->active_fe_index();
for (unsigned int f = 0; f < cell->n_faces(); ++f)
// in this case, only one fe should be active on the subface.
for (unsigned int sf = 0; sf < face->n_children(); ++sf)
{
- const auto & subface = face->child(sf);
+ const auto &subface = face->child(sf);
const unsigned int subface_fe_index =
subface->nth_active_fe_index(0);
Assert(subface->n_active_fe_indices() == 1, ExcInternalError());
*/
template <int dim>
void
-test(const std::vector<unsigned int> & n_refinements,
- const std::vector<unsigned int> & fe_indices,
- const hp::FECollection<dim> & fe_collection,
+test(const std::vector<unsigned int> &n_refinements,
+ const std::vector<unsigned int> &fe_indices,
+ const hp::FECollection<dim> &fe_collection,
const std::function<void(Triangulation<dim> &)> &grid_generator)
{
// setup grid
const auto solve_and_postprocess =
[&](const auto &poisson_operator,
- auto & x,
- auto & b) -> std::pair<unsigned int, double> {
+ auto &x,
+ auto &b) -> std::pair<unsigned int, double> {
ReductionControl reduction_control;
SolverCG<std::remove_reference_t<decltype(x)>> solver(reduction_control);
solver.solve(poisson_operator, x, b, PreconditionIdentity());
const auto solve_and_postprocess =
[&](const auto &poisson_operator,
- auto & x,
- auto & b) -> std::tuple<unsigned int, double, double, double> {
+ auto &x,
+ auto &b) -> std::tuple<unsigned int, double, double, double> {
ReductionControl reduction_control(1000, 1e-10, 1e-4);
SolverCG<std::remove_reference_t<decltype(x)>> solver(reduction_control);
solver.solve(poisson_operator, x, b, PreconditionIdentity());
{}
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
template <int dim>
void
SmoothSolution<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const
{
for (unsigned int i = 0; i < values.size(); ++i)
{}
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/ = 0) const override;
};
template <int dim>
void
SmoothRightHandSide<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const
{
for (unsigned int i = 0; i < values.size(); ++i)
const auto solve_and_postprocess =
[&](const auto &poisson_operator,
- auto & x,
- auto & b) -> std::pair<unsigned int, double> {
+ auto &x,
+ auto &b) -> std::pair<unsigned int, double> {
ReductionControl reduction_control(1000, 1e-7, 1e-3);
SolverCG<std::remove_reference_t<decltype(x)>> solver(reduction_control);
const unsigned int dofs_per_cell = fe_v.dofs_per_cell;
copy_data.reinit(cell, dofs_per_cell);
- const auto & q_points = scratch_data.get_quadrature_points();
+ const auto &q_points = scratch_data.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const std::vector<double> &JxW = scratch_data.get_JxW_values();
}
};
- const auto boundary_worker = [&](const auto & cell,
+ const auto boundary_worker = [&](const auto &cell,
const unsigned int &face_no,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEFaceValuesBase<dim> &fe_fv = scratch_data.reinit(cell, face_no);
- const auto & q_points = scratch_data.get_quadrature_points();
+ const auto &q_points = scratch_data.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const unsigned int dofs_per_cell = fe_fv.dofs_per_cell;
- const std::vector<double> & JxW = scratch_data.get_JxW_values();
+ const std::vector<double> &JxW = scratch_data.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals =
scratch_data.get_normal_vectors();
}
};
- const auto face_worker = [&](const auto & cell,
+ const auto face_worker = [&](const auto &cell,
const unsigned int &f,
const unsigned int &sf,
- const auto & ncell,
+ const auto &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEInterfaceValues<dim> &fe_iv =
scratch_data.reinit(cell, f, sf, ncell, nf, nsf);
- const auto & q_points = fe_iv.get_quadrature_points();
+ const auto &q_points = fe_iv.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
copy_data.face_data.emplace_back();
- CopyDataFace & copy_data_face = copy_data.face_data.back();
+ CopyDataFace ©_data_face = copy_data.face_data.back();
const unsigned int n_dofs_face = fe_iv.n_current_interface_dofs();
copy_data_face.joint_dof_indices = fe_iv.get_interface_dof_indices();
copy_data_face.cell_matrix.reinit(n_dofs_face, n_dofs_face);
- const std::vector<double> & JxW = fe_iv.get_JxW_values();
+ const std::vector<double> &JxW = fe_iv.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_iv.get_normal_vectors();
const double penalty = PENALTY;
const auto solve_and_postprocess =
[&](const auto &poisson_operator,
- auto & x,
- auto & b) -> std::pair<unsigned int, double> {
+ auto &x,
+ auto &b) -> std::pair<unsigned int, double> {
ReductionControl reduction_control(2000, 1e-7, 1e-2);
SolverCG<std::remove_reference_t<decltype(x)>> solver(reduction_control);
quad = std::make_shared<QGaussWedge<dim>>(degree + 1);
fe_mapping = std::make_shared<FE_WedgeP<dim>>(1);
face_quad = hp::QCollection<dim - 1>{QGaussSimplex<dim - 1>(degree + 1),
- QGaussSimplex<dim - 1>(degree + 1),
- QGauss<dim - 1>(degree + 1),
- QGauss<dim - 1>(degree + 1),
- QGauss<dim - 1>(degree + 1)};
+ QGaussSimplex<dim - 1>(degree + 1),
+ QGauss<dim - 1>(degree + 1),
+ QGauss<dim - 1>(degree + 1),
+ QGauss<dim - 1>(degree + 1)};
}
else if (v == 2)
{
quad = std::make_shared<QGaussPyramid<dim>>(degree + 1);
fe_mapping = std::make_shared<FE_PyramidP<dim>>(1);
face_quad = hp::QCollection<dim - 1>{QGauss<dim - 1>(degree + 1),
- QGaussSimplex<dim - 1>(degree + 1),
- QGaussSimplex<dim - 1>(degree + 1),
- QGaussSimplex<dim - 1>(degree + 1),
- QGaussSimplex<dim - 1>(degree + 1)};
+ QGaussSimplex<dim - 1>(degree + 1),
+ QGaussSimplex<dim - 1>(degree + 1),
+ QGaussSimplex<dim - 1>(degree + 1),
+ QGaussSimplex<dim - 1>(degree + 1)};
}
else
Assert(false, ExcNotImplemented());
#include "../tests.h"
void
-test_face(const std::vector<Point<3>> & vertices_,
+test_face(const std::vector<Point<3>> &vertices_,
const std::vector<CellData<3>> &cell_data_,
const unsigned int face_n)
{
void
test(const Triangulation<dim, spacedim> &tria,
const FiniteElement<dim, spacedim> &fe,
- const Quadrature<dim> & quad,
- const hp::QCollection<dim - 1> & face_quad,
- const Mapping<dim, spacedim> & mapping,
+ const Quadrature<dim> &quad,
+ const hp::QCollection<dim - 1> &face_quad,
+ const Mapping<dim, spacedim> &mapping,
const double r_boundary,
const bool do_use_fe_face_values = true)
{
#include "../tests.h"
-//#define HEX
+// #define HEX
using namespace dealii;
template <int dim>
struct ScratchData
{
- ScratchData(const Mapping<dim> & mapping,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quad,
+ ScratchData(const Mapping<dim> &mapping,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quad,
const Quadrature<dim - 1> &quad_face,
const UpdateFlags update_flags = update_values |
update_gradients |
{
public:
DGHeat(const bool hex,
- FiniteElement<dim> * fe,
- Mapping<dim> * mapping,
- Quadrature<dim> * quad,
+ FiniteElement<dim> *fe,
+ Mapping<dim> *mapping,
+ Quadrature<dim> *quad,
Quadrature<dim - 1> *face_quad,
unsigned int initial_refinement,
unsigned int number_refinement)
{
using Iterator = typename DoFHandler<dim>::active_cell_iterator;
- auto cell_worker = [&](const Iterator & cell,
+ auto cell_worker = [&](const Iterator &cell,
ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
const unsigned int n_dofs = scratch_data.fe_values.get_fe().dofs_per_cell;
copy_data.reinit(cell, n_dofs);
scratch_data.fe_values.reinit(cell);
const auto &q_points = scratch_data.fe_values.get_quadrature_points();
- const FEValues<dim> & fe_v = scratch_data.fe_values;
+ const FEValues<dim> &fe_v = scratch_data.fe_values;
const std::vector<double> &JxW = fe_v.get_JxW_values();
std::vector<double> f(q_points.size());
}
};
- auto boundary_worker = [&](const Iterator & cell,
+ auto boundary_worker = [&](const Iterator &cell,
const unsigned int &face_no,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
scratch_data.fe_interface_values.reinit(cell, face_no);
const FEFaceValuesBase<dim> &fe_face =
scratch_data.fe_interface_values.get_fe_face_values(0);
- const auto & q_points = fe_face.get_quadrature_points();
+ const auto &q_points = fe_face.get_quadrature_points();
const unsigned int n_facet_dofs = fe_face.get_fe().n_dofs_per_cell();
const std::vector<double> &JxW = fe_face.get_JxW_values();
}
};
- auto face_worker = [&](const Iterator & cell,
+ auto face_worker = [&](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
FEInterfaceValues<dim> &fe_iv = scratch_data.fe_interface_values;
fe_iv.reinit(cell, f, sf, ncell, nf, nsf);
copy_data_face.cell_matrix.reinit(n_dofs, n_dofs);
- const std::vector<double> & JxW = fe_iv.get_JxW_values();
+ const std::vector<double> &JxW = fe_iv.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_iv.get_normal_vectors();
tria.execute_coarsening_and_refinement();
// find face index on unrefined cell to neighboring cells
- const auto & unrefined_cell = tria.begin_active(0);
+ const auto &unrefined_cell = tria.begin_active(0);
unsigned int unrefined_f = numbers::invalid_unsigned_int;
for (unsigned int f = 0; f < unrefined_cell->n_faces(); ++f)
if (!unrefined_cell->face(f)->at_boundary())
template <int dim, int spacedim>
void
subdivided_hyper_rectangle_with_wedges(
- Triangulation<dim, spacedim> & tria,
+ Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &repetitions,
- const Point<dim> & p1,
- const Point<dim> & p2,
+ const Point<dim> &p1,
+ const Point<dim> &p2,
const bool colorize = false)
{
AssertDimension(dim, spacedim);
template <int dim, int spacedim>
void
subdivided_hyper_rectangle_with_pyramids(
- Triangulation<dim, spacedim> & tria,
+ Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &repetitions,
- const Point<dim> & p1,
- const Point<dim> & p2,
+ const Point<dim> &p1,
+ const Point<dim> &p2,
const bool colorize = false)
{
AssertDimension(dim, spacedim);
template <int dim, int spacedim>
void
subdivided_hyper_rectangle_with_simplices_mix(
- Triangulation<dim, spacedim> & tria,
+ Triangulation<dim, spacedim> &tria,
const std::vector<unsigned int> &repetitions,
- const Point<dim> & p1,
- const Point<dim> & p2,
+ const Point<dim> &p1,
+ const Point<dim> &p2,
const bool colorize = false)
{
AssertDimension(dim, spacedim);
Vector<double> solution(dof_handler.n_dofs());
Solution<dim> function;
AffineConstraints<double> dummy;
- const auto & mapping =
+ const auto &mapping =
reference_cell.template get_default_linear_mapping<dim>();
dummy.close();
Vector<double> solution(dof_handler.n_dofs());
Functions::CosineFunction<dim> function;
AffineConstraints<double> dummy;
- const auto & mapping =
+ const auto &mapping =
reference_cell.template get_default_linear_mapping<dim>();
dummy.close();
VectorTools::project(
value(const Point<dim> &p, const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
};
template <int dim>
void
right_hand_side(const std::vector<Point<dim>> &points,
- std::vector<Tensor<1, dim>> & values)
+ std::vector<Tensor<1, dim>> &values)
{
Assert(values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
BoundaryValues() = default;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
template <int dim>
void
BoundaryValues<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
(void)component;
template <int dim>
struct ScratchData
{
- ScratchData(const Mapping<dim> & mapping,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quadrature,
+ ScratchData(const Mapping<dim> &mapping,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quadrature,
const Quadrature<dim - 1> &quadrature_face,
const UpdateFlags update_flags = update_values |
update_gradients |
using Iterator = typename DoFHandler<dim>::active_cell_iterator;
const BoundaryValues<dim> boundary_function;
- const auto cell_worker = [&](const Iterator & cell,
+ const auto cell_worker = [&](const Iterator &cell,
ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
const unsigned int n_dofs =
scratch_data.fe_values.get_fe().n_dofs_per_cell();
copy_data.reinit(cell, n_dofs);
const auto &q_points = scratch_data.fe_values.get_quadrature_points();
- const FEValues<dim> & fe_v = scratch_data.fe_values;
+ const FEValues<dim> &fe_v = scratch_data.fe_values;
const std::vector<double> &JxW = fe_v.get_JxW_values();
for (unsigned int point = 0; point < fe_v.n_quadrature_points; ++point)
}
};
- const auto boundary_worker = [&](const Iterator & cell,
+ const auto boundary_worker = [&](const Iterator &cell,
const unsigned int &face_no,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
scratch_data.fe_interface_values.reinit(cell, face_no);
const FEFaceValuesBase<dim> &fe_face =
scratch_data.fe_interface_values.get_fe_face_values(0);
const auto &q_points = fe_face.get_quadrature_points();
const unsigned int n_facet_dofs = fe_face.get_fe().n_dofs_per_cell();
- const std::vector<double> & JxW = fe_face.get_JxW_values();
+ const std::vector<double> &JxW = fe_face.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_face.get_normal_vectors();
std::vector<double> g(q_points.size());
}
};
- const auto face_worker = [&](const Iterator & cell,
+ const auto face_worker = [&](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
FEInterfaceValues<dim> &fe_iv = scratch_data.fe_interface_values;
fe_iv.reinit(cell, f, sf, ncell, nf, nsf);
const auto &q_points = fe_iv.get_quadrature_points();
copy_data_face.cell_matrix.reinit(n_dofs, n_dofs);
- const std::vector<double> & JxW = fe_iv.get_JxW_values();
+ const std::vector<double> &JxW = fe_iv.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_iv.get_normal_vectors();
for (unsigned int qpoint = 0; qpoint < q_points.size(); ++qpoint)
#include <fstream>
#include <iostream>
-//#define HEX
+// #define HEX
namespace Step12
{
BoundaryValues() = default;
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
};
template <int dim>
void
BoundaryValues<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component) const
{
(void)component;
template <int dim>
struct ScratchData
{
- ScratchData(const Mapping<dim> & mapping,
- const FiniteElement<dim> & fe,
- const Quadrature<dim> & quad,
+ ScratchData(const Mapping<dim> &mapping,
+ const FiniteElement<dim> &fe,
+ const Quadrature<dim> &quad,
const Quadrature<dim - 1> &quad_face,
const UpdateFlags update_flags = update_values |
update_gradients |
using Iterator = typename DoFHandler<dim>::active_cell_iterator;
const BoundaryValues<dim> boundary_function;
- auto cell_worker = [&](const Iterator & cell,
+ auto cell_worker = [&](const Iterator &cell,
ScratchData<dim> &scratch_data,
- CopyData & copy_data) {
+ CopyData ©_data) {
const unsigned int n_dofs = scratch_data.fe_values.get_fe().dofs_per_cell;
copy_data.reinit(cell, n_dofs);
scratch_data.fe_values.reinit(cell);
const auto &q_points = scratch_data.fe_values.get_quadrature_points();
- const FEValues<dim> & fe_v = scratch_data.fe_values;
+ const FEValues<dim> &fe_v = scratch_data.fe_values;
const std::vector<double> &JxW = fe_v.get_JxW_values();
for (unsigned int point = 0; point < fe_v.n_quadrature_points; ++point)
}
};
- auto boundary_worker = [&](const Iterator & cell,
+ auto boundary_worker = [&](const Iterator &cell,
const unsigned int &face_no,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
scratch_data.fe_interface_values.reinit(cell, face_no);
const FEFaceValuesBase<dim> &fe_face =
scratch_data.fe_interface_values.get_fe_face_values(0);
const auto &q_points = fe_face.get_quadrature_points();
const unsigned int n_facet_dofs = fe_face.get_fe().n_dofs_per_cell();
- const std::vector<double> & JxW = fe_face.get_JxW_values();
+ const std::vector<double> &JxW = fe_face.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_face.get_normal_vectors();
std::vector<double> g(q_points.size());
}
};
- auto face_worker = [&](const Iterator & cell,
+ auto face_worker = [&](const Iterator &cell,
const unsigned int &f,
const unsigned int &sf,
- const Iterator & ncell,
+ const Iterator &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- ScratchData<dim> & scratch_data,
- CopyData & copy_data) {
+ ScratchData<dim> &scratch_data,
+ CopyData ©_data) {
FEInterfaceValues<dim> &fe_iv = scratch_data.fe_interface_values;
fe_iv.reinit(cell, f, sf, ncell, nf, nsf);
const auto &q_points = fe_iv.get_quadrature_points();
copy_data_face.cell_matrix.reinit(n_dofs, n_dofs);
- const std::vector<double> & JxW = fe_iv.get_JxW_values();
+ const std::vector<double> &JxW = fe_iv.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_iv.get_normal_vectors();
for (unsigned int qpoint = 0; qpoint < q_points.size(); ++qpoint)
void
AdvectionProblem<dim>::run()
{
- //#ifdef HEX
- // for (unsigned int cycle = 0; cycle < 6; ++cycle)
- //#else
+ // #ifdef HEX
+ // for (unsigned int cycle = 0; cycle < 6; ++cycle)
+ // #else
for (unsigned int cycle = 0; cycle < 1; ++cycle)
- //#endif
+ // #endif
{
deallog << "Cycle " << cycle << std::endl;
public:
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
public:
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
{}
void
value_list(const std::vector<Point<dim>> &points,
- std::vector<Point<dim>> & values) const;
+ std::vector<Point<dim>> &values) const;
};
template <int dim>
void
RHS<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
// Assert(values.size() == points.size(),
template <int dim>
void
Beta<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<Point<dim>> & values) const
+ std::vector<Point<dim>> &values) const
{
// Assert(values.size() == points.size(),
// ExcDimensionMismatch(values.size(), points.size()));
for (unsigned int i = 0; i < std::min(points.size(), values.size()); ++i)
{
const Point<dim> &p = points[i];
- Point<dim> & beta = values[i];
+ Point<dim> &beta = values[i];
beta(0) = -p(1);
beta(1) = p(0);
template <int dim>
void
BoundaryValues<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
// Assert(values.size() == points.size(),
void
assemble_cell_term(const hp::FEValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const;
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const;
void
assemble_boundary_term(const hp::FEFaceValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const;
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const;
template <class X, class Y>
void
- assemble_face_term1(const X & fe_v,
- const Y & fe_v_neighbor,
+ assemble_face_term1(const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix) const;
template <class X, class Y>
void
- assemble_face_term2(const X & fe_v,
- const Y & fe_v_neighbor,
+ assemble_face_term2(const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix,
FullMatrix<double> &ui_ve_matrix,
void
DGTransportEquation<dim>::assemble_boundary_term(
const hp::FEFaceValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const
{
const std::vector<double> &JxW =
fe_v.get_present_fe_values().get_JxW_values();
template <class X, class Y>
void
DGTransportEquation<dim>::assemble_face_term1(
- const X & fe_v,
- const Y & fe_v_neighbor,
+ const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix) const
{
template <class X, class Y>
void
DGTransportEquation<dim>::assemble_face_term2(
- const X & fe_v,
- const Y & fe_v_neighbor,
+ const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix,
FullMatrix<double> &ui_ve_matrix,
public:
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
public:
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const;
};
{}
void
value_list(const std::vector<Point<dim>> &points,
- std::vector<Point<dim>> & values) const;
+ std::vector<Point<dim>> &values) const;
};
template <int dim>
void
RHS<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
// Assert(values.size() == points.size(),
template <int dim>
void
Beta<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<Point<dim>> & values) const
+ std::vector<Point<dim>> &values) const
{
// Assert(values.size() == points.size(),
// ExcDimensionMismatch(values.size(), points.size()));
for (unsigned int i = 0; i < std::min(points.size(), values.size()); ++i)
{
const Point<dim> &p = points[i];
- Point<dim> & beta = values[i];
+ Point<dim> &beta = values[i];
beta(0) = -p(1);
beta(1) = p(0);
template <int dim>
void
BoundaryValues<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int) const
{
// Assert(values.size() == points.size(),
void
assemble_cell_term(const hp::FEValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const;
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const;
void
assemble_boundary_term(const hp::FEFaceValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const;
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const;
template <class X, class Y>
void
- assemble_face_term1(const X & fe_v,
- const Y & fe_v_neighbor,
+ assemble_face_term1(const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix) const;
template <class X, class Y>
void
- assemble_face_term2(const X & fe_v,
- const Y & fe_v_neighbor,
+ assemble_face_term2(const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix,
FullMatrix<double> &ui_ve_matrix,
void
DGTransportEquation<dim>::assemble_boundary_term(
const hp::FEFaceValues<dim> &fe_v,
- FullMatrix<double> & ui_vi_matrix,
- Vector<double> & cell_vector) const
+ FullMatrix<double> &ui_vi_matrix,
+ Vector<double> &cell_vector) const
{
const std::vector<double> &JxW =
fe_v.get_present_fe_values().get_JxW_values();
template <class X, class Y>
void
DGTransportEquation<dim>::assemble_face_term1(
- const X & fe_v,
- const Y & fe_v_neighbor,
+ const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix) const
{
template <class X, class Y>
void
DGTransportEquation<dim>::assemble_face_term2(
- const X & fe_v,
- const Y & fe_v_neighbor,
+ const X &fe_v,
+ const Y &fe_v_neighbor,
FullMatrix<double> &ui_vi_matrix,
FullMatrix<double> &ue_vi_matrix,
FullMatrix<double> &ui_ve_matrix,
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const override
+ std::vector<Vector<double>> &value_list) const override
{
const unsigned int n_points = points.size();
#include <deal.II/grid/grid_generator.h>
-//#define HEX
+// #define HEX
const unsigned int degree = 1;
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const override;
+ std::vector<Vector<double>> &value_list) const override;
};
void
BodyForce<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
const unsigned int n_points = points.size();
virtual void
vector_value_list(const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const override;
+ std::vector<Vector<double>> &value_list) const override;
private:
const double velocity;
void
IncrementalBoundaryValues<dim>::vector_value_list(
const std::vector<Point<dim>> &points,
- std::vector<Vector<double>> & value_list) const
+ std::vector<Vector<double>> &value_list) const
{
const unsigned int n_points = points.size();
{}
virtual double
- value(const Point<dim> & p,
+ value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
{}
virtual double
- value(const Point<dim> & p,
+ value(const Point<dim> &p,
const unsigned int component = 0) const override;
};
template <int dim>
void
ExactSolution<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
Assert(values.size() == dim + 1,
ExcDimensionMismatch(values.size(), dim + 1));
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<2, dim>> & values) const override;
+ std::vector<Tensor<2, dim>> &values) const override;
};
template <int dim>
void
KInverse<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<Tensor<2, dim>> & values) const
+ std::vector<Tensor<2, dim>> &values) const
{
(void)points;
AssertDimension(points.size(), values.size());
: Function<dim>(1)
{}
virtual double
- value(const Point<dim> & p,
+ value(const Point<dim> &p,
const unsigned int component = 0) const override
{
(void)component;
class InverseMatrix : public Subscriptor
{
public:
- InverseMatrix(const MatrixType & m,
+ InverseMatrix(const MatrixType &m,
const PreconditionerType &preconditioner);
template <typename VectorType>
void
private:
const SmartPointer<const MatrixType> matrix;
- const PreconditionerType & preconditioner;
+ const PreconditionerType &preconditioner;
};
template <class MatrixType, class PreconditionerType>
InverseMatrix<MatrixType, PreconditionerType>::InverseMatrix(
- const MatrixType & m,
+ const MatrixType &m,
const PreconditionerType &preconditioner)
: matrix(&m)
, preconditioner(preconditioner)
template <typename VectorType>
void
InverseMatrix<MatrixType, PreconditionerType>::vmult(
- VectorType & dst,
+ VectorType &dst,
const VectorType &src) const
{
SolverControl solver_control(src.size(), 1e-7 * src.l2_norm());
const TrilinosWrappers::BlockSparseMatrix &S,
const InverseMatrix<TrilinosWrappers::SparseMatrix,
PreconditionerTypeMp> &Mpinv,
- const PreconditionerTypeA & Apreconditioner);
+ const PreconditionerTypeA &Apreconditioner);
void
- vmult(TrilinosWrappers::MPI::BlockVector & dst,
+ vmult(TrilinosWrappers::MPI::BlockVector &dst,
const TrilinosWrappers::MPI::BlockVector &src) const;
private:
const SmartPointer<const InverseMatrix<TrilinosWrappers::SparseMatrix,
PreconditionerTypeMp>>
m_inverse;
- const PreconditionerTypeA & a_preconditioner;
+ const PreconditionerTypeA &a_preconditioner;
mutable TrilinosWrappers::MPI::Vector tmp;
};
template <class PreconditionerTypeA, class PreconditionerTypeMp>
const TrilinosWrappers::BlockSparseMatrix &S,
const InverseMatrix<TrilinosWrappers::SparseMatrix,
PreconditionerTypeMp> &Mpinv,
- const PreconditionerTypeA & Apreconditioner)
+ const PreconditionerTypeA &Apreconditioner)
: stokes_matrix(&S)
, m_inverse(&Mpinv)
, a_preconditioner(Apreconditioner)
template <class PreconditionerTypeA, class PreconditionerTypeMp>
void
BlockSchurPreconditioner<PreconditionerTypeA, PreconditionerTypeMp>::vmult(
- TrilinosWrappers::MPI::BlockVector & dst,
+ TrilinosWrappers::MPI::BlockVector &dst,
const TrilinosWrappers::MPI::BlockVector &src) const
{
a_preconditioner.vmult(dst.block(0), src.block(0));
refine_mesh(const unsigned int max_grid_level);
double
compute_viscosity(
- const std::vector<double> & old_temperature,
- const std::vector<double> & old_old_temperature,
+ const std::vector<double> &old_temperature,
+ const std::vector<double> &old_old_temperature,
const std::vector<Tensor<1, dim>> &old_temperature_grads,
const std::vector<Tensor<1, dim>> &old_old_temperature_grads,
- const std::vector<double> & old_temperature_laplacians,
- const std::vector<double> & old_old_temperature_laplacians,
+ const std::vector<double> &old_temperature_laplacians,
+ const std::vector<double> &old_old_temperature_laplacians,
const std::vector<Tensor<1, dim>> &old_velocity_values,
const std::vector<Tensor<1, dim>> &old_old_velocity_values,
- const std::vector<double> & gamma_values,
+ const std::vector<double> &gamma_values,
const double global_u_infty,
const double global_T_variation,
const double cell_diameter) const;
double
BoussinesqFlowProblem<dim>::get_maximal_velocity() const
{
- const auto & quadrature_formula = quadrature_stokes;
+ const auto &quadrature_formula = quadrature_stokes;
const unsigned int n_q_points = quadrature_formula.size();
FEValues<dim> fe_values(mapping,
stokes_fe,
std::pair<double, double>
BoussinesqFlowProblem<dim>::get_extrapolated_temperature_range() const
{
- const auto & quadrature_formula = quadrature_temperature;
+ const auto &quadrature_formula = quadrature_temperature;
const unsigned int n_q_points = quadrature_formula.size();
FEValues<dim> fe_values(mapping,
temperature_fe,
template <int dim>
double
BoussinesqFlowProblem<dim>::compute_viscosity(
- const std::vector<double> & old_temperature,
- const std::vector<double> & old_old_temperature,
+ const std::vector<double> &old_temperature,
+ const std::vector<double> &old_old_temperature,
const std::vector<Tensor<1, dim>> &old_temperature_grads,
const std::vector<Tensor<1, dim>> &old_old_temperature_grads,
- const std::vector<double> & old_temperature_laplacians,
- const std::vector<double> & old_old_temperature_laplacians,
+ const std::vector<double> &old_temperature_laplacians,
+ const std::vector<double> &old_old_temperature_laplacians,
const std::vector<Tensor<1, dim>> &old_velocity_values,
const std::vector<Tensor<1, dim>> &old_old_velocity_values,
- const std::vector<double> & gamma_values,
+ const std::vector<double> &gamma_values,
const double global_u_infty,
const double global_T_variation,
const double cell_diameter) const
BoussinesqFlowProblem<dim>::assemble_stokes_preconditioner()
{
stokes_preconditioner_matrix = 0;
- const auto & quadrature_formula = quadrature_stokes;
+ const auto &quadrature_formula = quadrature_stokes;
FEValues<dim> stokes_fe_values(mapping,
stokes_fe,
quadrature_formula,
if (rebuild_stokes_matrix == true)
stokes_matrix = 0;
stokes_rhs = 0;
- const auto & quadrature_formula = quadrature_stokes;
+ const auto &quadrature_formula = quadrature_stokes;
FEValues<dim> stokes_fe_values(
mapping,
stokes_fe,
return;
temperature_mass_matrix = 0;
temperature_stiffness_matrix = 0;
- const auto & quadrature_formula = quadrature_temperature;
+ const auto &quadrature_formula = quadrature_temperature;
FEValues<dim> temperature_fe_values(mapping,
temperature_fe,
quadrature_formula,
temperature_matrix.add(time_step, temperature_stiffness_matrix);
}
temperature_rhs = 0;
- const auto & quadrature_formula = quadrature_temperature;
+ const auto &quadrature_formula = quadrature_temperature;
FEValues<dim> temperature_fe_values(mapping,
temperature_fe,
quadrature_formula,
value(const Point<dim> &p, const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & p,
+ gradient(const Point<dim> &p,
const unsigned int component = 0) const override;
};
* Author: Timo Heister, Clemson University, 2016
*/
-//#define HEX
+// #define HEX
#include <deal.II/base/function.h>
#include <deal.II/base/quadrature_lib.h>
private:
const SmartPointer<const Matrix> matrix;
- const Preconditioner & preconditioner;
+ const Preconditioner &preconditioner;
};
template <class Matrix, class Preconditioner>
InverseMatrix<Matrix, Preconditioner>::InverseMatrix(
- const Matrix & m,
+ const Matrix &m,
const Preconditioner &preconditioner)
: matrix(&m)
, preconditioner(preconditioner)
template <class Matrix, class Preconditioner>
template <typename VectorType>
void
- InverseMatrix<Matrix, Preconditioner>::vmult(VectorType & dst,
+ InverseMatrix<Matrix, Preconditioner>::vmult(VectorType &dst,
const VectorType &src) const
{
SolverControl solver_control(src.size(),
template <class PreconditionerA, class PreconditionerS>
void
BlockDiagonalPreconditioner<PreconditionerA, PreconditionerS>::vmult(
- LA::MPI::BlockVector & dst,
+ LA::MPI::BlockVector &dst,
const LA::MPI::BlockVector &src) const
{
preconditioner_A.vmult(dst.block(0), src.block(0));
template <int dim>
void
RightHandSide<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
const double R_x = p[0];
const double R_y = p[1];
template <int dim>
void
ExactSolution<dim>::vector_value(const Point<dim> &p,
- Vector<double> & values) const
+ Vector<double> &values) const
{
const double R_x = p[0];
const double R_y = p[1];
-//#define HEX
+// #define HEX
#include <deal.II/base/conditional_ostream.h>
#include <deal.II/base/function.h>
// -1)} + \frac 12 \rho \|u\|^2$.
template <int dim>
double
- ExactSolution<dim>::value(const Point<dim> & x,
+ ExactSolution<dim>::value(const Point<dim> &x,
const unsigned int component) const
{
const double t = this->get_time();
perform_time_step(const Operator &pde_operator,
const double current_time,
const double time_step,
- VectorType & solution,
- VectorType & vec_ri,
- VectorType & vec_ki) const
+ VectorType &solution,
+ VectorType &vec_ri,
+ VectorType &vec_ki) const
{
AssertDimension(ai.size() + 1, bi.size());
inline DEAL_II_ALWAYS_INLINE //
Tensor<1, n_components, Number>
operator*(const Tensor<1, n_components, Tensor<1, dim, Number>> &matrix,
- const Tensor<1, dim, Number> & vector)
+ const Tensor<1, dim, Number> &vector)
{
Tensor<1, n_components, Number> result;
for (unsigned int d = 0; d < n_components; ++d)
Tensor<1, dim + 2, Number>
euler_numerical_flux(const Tensor<1, dim + 2, Number> &u_m,
const Tensor<1, dim + 2, Number> &u_p,
- const Tensor<1, dim, Number> & normal)
+ const Tensor<1, dim, Number> &normal)
{
const auto velocity_m = euler_velocity<dim>(u_m);
const auto velocity_p = euler_velocity<dim>(u_p);
// where all components of the solution are set.
template <int dim, typename Number>
VectorizedArray<Number>
- evaluate_function(const Function<dim> & function,
+ evaluate_function(const Function<dim> &function,
const Point<dim, VectorizedArray<Number>> &p_vectorized,
const unsigned int component)
{
template <int dim, typename Number, int n_components = dim + 2>
Tensor<1, n_components, VectorizedArray<Number>>
- evaluate_function(const Function<dim> & function,
+ evaluate_function(const Function<dim> &function,
const Point<dim, VectorizedArray<Number>> &p_vectorized)
{
AssertDimension(function.n_components, n_components);
void
apply(const double current_time,
const LinearAlgebra::distributed::Vector<Number> &src,
- LinearAlgebra::distributed::Vector<Number> & dst) const;
+ LinearAlgebra::distributed::Vector<Number> &dst) const;
void
- vmult(LinearAlgebra::distributed::Vector<Number> & dst,
+ vmult(LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src) const;
void
const Number factor_solution,
const Number factor_ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
- LinearAlgebra::distributed::Vector<Number> & solution,
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &solution,
LinearAlgebra::distributed::Vector<Number> &next_ri) const;
void
- project(const Function<dim> & function,
+ project(const Function<dim> &function,
LinearAlgebra::distributed::Vector<Number> &solution) const;
std::array<double, 3>
compute_errors(
- const Function<dim> & function,
+ const Function<dim> &function,
const LinearAlgebra::distributed::Vector<Number> &solution) const;
double
void
local_apply_inverse_mass_matrix(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_apply_cell(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_apply_face(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
void
local_apply_boundary_face(
- const MatrixFree<dim, Number> & data,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ const MatrixFree<dim, Number> &data,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const;
+ const std::pair<unsigned int, unsigned int> &cell_range) const;
};
template <int dim, int degree, int n_points_1d>
void
EulerOperator<dim, degree, n_points_1d>::reinit(
- const Mapping<dim> & mapping,
+ const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler)
{
const std::vector<const DoFHandler<dim> *> dof_handlers = {&dof_handler};
void
EulerOperator<dim, degree, n_points_1d>::local_apply_cell(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
#ifdef HEX
FEEvaluation<dim, degree, n_points_1d, dim + 2, Number> phi(data);
void
EulerOperator<dim, degree, n_points_1d>::local_apply_face(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
#ifdef HEX
FEFaceEvaluation<dim, degree, n_points_1d, dim + 2, Number> phi_m(data,
void
EulerOperator<dim, degree, n_points_1d>::local_apply_boundary_face(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & face_range) const
+ const std::pair<unsigned int, unsigned int> &face_range) const
{
#ifdef HEX
FEFaceEvaluation<dim, degree, n_points_1d, dim + 2, Number> phi(data, true);
void
EulerOperator<dim, degree, n_points_1d>::local_apply_inverse_mass_matrix(
const MatrixFree<dim, Number> &,
- LinearAlgebra::distributed::Vector<Number> & dst,
+ LinearAlgebra::distributed::Vector<Number> &dst,
const LinearAlgebra::distributed::Vector<Number> &src,
- const std::pair<unsigned int, unsigned int> & cell_range) const
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, degree, degree + 1, dim + 2, Number> phi(data, 0, 1);
MatrixFreeOperators::CellwiseInverseMassMatrix<dim, degree, dim + 2, Number>
EulerOperator<dim, degree, n_points_1d>::apply(
const double current_time,
const LinearAlgebra::distributed::Vector<Number> &src,
- LinearAlgebra::distributed::Vector<Number> & dst) const
+ LinearAlgebra::distributed::Vector<Number> &dst) const
{
{
TimerOutput::Scope t(timer, "apply - integrals");
const Number factor_solution,
const Number factor_ai,
const LinearAlgebra::distributed::Vector<Number> ¤t_ri,
- LinearAlgebra::distributed::Vector<Number> & vec_ki,
- LinearAlgebra::distributed::Vector<Number> & solution,
- LinearAlgebra::distributed::Vector<Number> & next_ri) const
+ LinearAlgebra::distributed::Vector<Number> &vec_ki,
+ LinearAlgebra::distributed::Vector<Number> &solution,
+ LinearAlgebra::distributed::Vector<Number> &next_ri) const
{
{
TimerOutput::Scope t(timer, "rk_stage - integrals L_h");
template <int dim, int degree, int n_points_1d>
void
EulerOperator<dim, degree, n_points_1d>::project(
- const Function<dim> & function,
+ const Function<dim> &function,
LinearAlgebra::distributed::Vector<Number> &solution) const
{
FEEvaluation<dim, degree, degree + 1, dim + 2, Number> phi(data, 0, 1);
template <int dim, int degree, int n_points_1d>
std::array<double, 3>
EulerOperator<dim, degree, n_points_1d>::compute_errors(
- const Function<dim> & function,
+ const Function<dim> &function,
const LinearAlgebra::distributed::Vector<Number> &solution) const
{
TimerOutput::Scope t(timer, "compute errors");
void
EulerProblem<dim>::Postprocessor::evaluate_vector_field(
const DataPostprocessorInputs::Vector<dim> &inputs,
- std::vector<Vector<double>> & computed_quantities) const
+ std::vector<Vector<double>> &computed_quantities) const
{
const unsigned int n_evaluation_points = inputs.solution_values.size();
virtual void
vector_value(const Point<dim> &point,
- Vector<double> & values) const override;
+ Vector<double> &values) const override;
};
template <int dim>
void
Vortex<dim>::vector_value(const Point<dim> &point,
- Vector<double> & values) const
+ Vector<double> &values) const
{
const double T = 4;
const double t = this->get_time();
{}
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int component = 0) const override;
virtual Tensor<1, dim>
- gradient(const Point<dim> & point,
+ gradient(const Point<dim> &point,
const unsigned int component = 0) const override;
};
template <int dim>
void
SmoothSolution<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const
{
using numbers::PI;
{}
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const override;
};
template <int dim>
void
SmoothRightHandSide<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const
{
using numbers::PI;
{}
virtual void
value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const override;
private:
template <int dim>
void
SingularRightHandSide<dim>::value_list(const std::vector<Point<dim>> &points,
- std::vector<double> & values,
+ std::vector<double> &values,
const unsigned int /*component*/) const
{
for (unsigned int i = 0; i < values.size(); ++i)
const unsigned int dofs_per_cell = fe_v.dofs_per_cell;
copy_data.reinit(cell, dofs_per_cell);
- const auto & q_points = scratch_data.get_quadrature_points();
+ const auto &q_points = scratch_data.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const std::vector<double> &JxW = scratch_data.get_JxW_values();
}
};
- const auto boundary_worker = [&](const auto & cell,
+ const auto boundary_worker = [&](const auto &cell,
const unsigned int &face_no,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEFaceValuesBase<dim> &fe_fv = scratch_data.reinit(cell, face_no);
Assert(fe_fv.get_cell() == cell, ExcInternalError());
Assert(fe_fv.get_face_number() == face_no, ExcInternalError());
- const auto & q_points = scratch_data.get_quadrature_points();
+ const auto &q_points = scratch_data.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const unsigned int dofs_per_cell = fe_fv.dofs_per_cell;
- const std::vector<double> & JxW = scratch_data.get_JxW_values();
+ const std::vector<double> &JxW = scratch_data.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals =
scratch_data.get_normal_vectors();
}
};
- const auto face_worker = [&](const auto & cell,
+ const auto face_worker = [&](const auto &cell,
const unsigned int &f,
const unsigned int &sf,
- const auto & ncell,
+ const auto &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEInterfaceValues<dim> &fe_iv =
scratch_data.reinit(cell, f, sf, ncell, nf, nsf);
Assert(fe_iv.get_face_number(1) == nf, ExcInternalError());
copy_data.face_data.emplace_back();
- CopyDataFace & copy_data_face = copy_data.face_data.back();
+ CopyDataFace ©_data_face = copy_data.face_data.back();
const unsigned int n_dofs_face = fe_iv.n_current_interface_dofs();
copy_data_face.joint_dof_indices = fe_iv.get_interface_dof_indices();
copy_data_face.cell_matrix.reinit(n_dofs_face, n_dofs_face);
- const std::vector<double> & JxW = fe_iv.get_JxW_values();
+ const std::vector<double> &JxW = fe_iv.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_iv.get_normal_vectors();
const double extent1 = cell->measure() / cell->face(f)->measure();
copy_data.cell_index = cell->active_cell_index();
- const auto & q_points = fe_v.get_quadrature_points();
+ const auto &q_points = fe_v.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const std::vector<double> &JxW = fe_v.get_JxW_values();
copy_data.value = hk * hk * residual_norm_square;
};
- const auto boundary_worker = [&](const auto & cell,
+ const auto boundary_worker = [&](const auto &cell,
const unsigned int &face_no,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEFaceValuesBase<dim> &fe_fv = scratch_data.reinit(cell, face_no);
- const auto & q_points = fe_fv.get_quadrature_points();
+ const auto &q_points = fe_fv.get_quadrature_points();
const unsigned n_q_points = q_points.size();
const std::vector<double> &JxW = fe_fv.get_JxW_values();
copy_data.value += penalty * difference_norm_square;
};
- const auto face_worker = [&](const auto & cell,
+ const auto face_worker = [&](const auto &cell,
const unsigned int &f,
const unsigned int &sf,
- const auto & ncell,
+ const auto &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEInterfaceValues<dim> &fe_iv =
scratch_data.reinit(cell, f, sf, ncell, nf, nsf);
copy_data_face.cell_indices[0] = cell->active_cell_index();
copy_data_face.cell_indices[1] = ncell->active_cell_index();
- const std::vector<double> & JxW = fe_iv.get_JxW_values();
+ const std::vector<double> &JxW = fe_iv.get_JxW_values();
const std::vector<Tensor<1, dim>> &normals = fe_iv.get_normal_vectors();
- const auto & q_points = fe_iv.get_quadrature_points();
+ const auto &q_points = fe_iv.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
std::vector<double> jump(n_q_points);
copy_data.cell_index = cell->active_cell_index();
- const auto & q_points = fe_v.get_quadrature_points();
+ const auto &q_points = fe_v.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
const std::vector<double> &JxW = fe_v.get_JxW_values();
copy_data.value = norm_square;
};
- const auto boundary_worker = [&](const auto & cell,
+ const auto boundary_worker = [&](const auto &cell,
const unsigned int &face_no,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEFaceValuesBase<dim> &fe_fv = scratch_data.reinit(cell, face_no);
- const auto & q_points = fe_fv.get_quadrature_points();
+ const auto &q_points = fe_fv.get_quadrature_points();
const unsigned n_q_points = q_points.size();
const std::vector<double> &JxW = fe_fv.get_JxW_values();
copy_data.value += penalty * difference_norm_square;
};
- const auto face_worker = [&](const auto & cell,
+ const auto face_worker = [&](const auto &cell,
const unsigned int &f,
const unsigned int &sf,
- const auto & ncell,
+ const auto &ncell,
const unsigned int &nf,
const unsigned int &nsf,
- auto & scratch_data,
- auto & copy_data) {
+ auto &scratch_data,
+ auto ©_data) {
const FEInterfaceValues<dim> &fe_iv =
scratch_data.reinit(cell, f, sf, ncell, nf, nsf);
const std::vector<double> &JxW = fe_iv.get_JxW_values();
- const auto & q_points = fe_iv.get_quadrature_points();
+ const auto &q_points = fe_iv.get_quadrature_points();
const unsigned int n_q_points = q_points.size();
std::vector<double> jump(n_q_points);
template <int dim>
void
output(const Triangulation<dim> &tr,
- const std::string & filename,
+ const std::string &filename,
const bool view_levels,
const bool include_artificial)
{
template <typename SolverType, typename MatrixType, typename VectorType>
void
-check_solve(SolverType & solver,
- const SolverControl & solver_control,
- const MatrixType & A,
- const MatrixType & B,
- std::vector<VectorType> & u,
+check_solve(SolverType &solver,
+ const SolverControl &solver_control,
+ const MatrixType &A,
+ const MatrixType &B,
+ std::vector<VectorType> &u,
std::vector<PetscScalar> &v)
{
deallog << "Solver type: " << typeid(solver).name() << std::endl;
template <typename SolverType, typename MatrixType, typename VectorType>
void
-check_solve(SolverType & solver,
+check_solve(SolverType &solver,
const unsigned int solver_number,
- const SolverControl & solver_control,
- const MatrixType & A,
- std::vector<VectorType> & u,
+ const SolverControl &solver_control,
+ const MatrixType &A,
+ std::vector<VectorType> &u,
std::vector<PetscScalar> &v)
{
deallog << "Solver type: " << typeid(solver).name() << std::endl;
template <int dim>
void
create_and_output_flux_sparsity_with_filter(
- DoFHandler<dim> & dof_handler,
+ DoFHandler<dim> &dof_handler,
std::function<bool(const typename DoFHandler<dim>::active_cell_iterator,
const unsigned int)> filter)
{
coupling,
coupling,
numbers::invalid_subdomain_id,
- [&](const auto & cell,
+ [&](const auto &cell,
const unsigned int face_index) {
return filter(cell, face_index);
});
using SparsityPatternBase::size_type;
virtual void
- add_row_entries(const size_type & row,
+ add_row_entries(const size_type &row,
const ArrayView<const size_type> &columns,
const bool indices_are_sorted = false) override
{
void
do_copy_from(
const std::list<std::set<unsigned int, std::greater<unsigned int>>> &sparsity,
- SparsityPattern & sp4)
+ SparsityPattern &sp4)
{
sp4.copy_from((N - 1) * (N - 1),
(N - 1) * (N - 1),
void
do_copy_from(
const std::list<std::set<unsigned int, std::greater<unsigned int>>> &sparsity,
- ChunkSparsityPattern & sp4)
+ ChunkSparsityPattern &sp4)
{
sp4.copy_from((N - 1) * (N - 1),
(N - 1) * (N - 1),
};
ode.jacobian_times_vector = [&](const VectorType &src,
- VectorType & dst,
+ VectorType &dst,
double t,
const VectorType & /*y*/,
const VectorType & /*fy*/) {
};
ode.jacobian_times_vector = [&](const VectorType &v,
- VectorType & Jv,
+ VectorType &Jv,
double t,
const VectorType &y,
const VectorType &fy) { J.vmult(Jv, v); };
ode.solve_linearized_system =
[&](SUNDIALS::SundialsOperator<VectorType> &op,
SUNDIALS::SundialsPreconditioner<VectorType> &,
- VectorType & x,
+ VectorType &x,
const VectorType &b,
double tol) {
ReductionControl control;
};
ode.jacobian_times_vector = [&](const VectorType &v,
- VectorType & Jv,
+ VectorType &Jv,
double t,
const VectorType &y,
const VectorType &fy) { J.vmult(Jv, v); };
ode.solve_linearized_system =
- [&](SUNDIALS::SundialsOperator<VectorType> & op,
+ [&](SUNDIALS::SundialsOperator<VectorType> &op,
SUNDIALS::SundialsPreconditioner<VectorType> &prec,
- VectorType & x,
- const VectorType & b,
+ VectorType &x,
+ const VectorType &b,
double tol) {
ReductionControl control;
SolverCG<VectorType> solver_cg(control);
const VectorType &y,
const VectorType &fy,
int jok,
- int & jcur,
+ int &jcur,
double gamma) {
deallog << "jacobian_preconditioner_setup called\n";
};
const VectorType &y,
const VectorType &fy,
const VectorType &r,
- VectorType & z,
+ VectorType &z,
double gamma,
double delta,
int lr) {
};
ode.jacobian_times_vector = [&](const VectorType &v,
- VectorType & Jv,
+ VectorType &Jv,
double t,
const VectorType &y,
const VectorType &fy) { K.vmult(Jv, v); };
const auto solve_function =
- [&](SUNDIALS::SundialsOperator<VectorType> & op,
+ [&](SUNDIALS::SundialsOperator<VectorType> &op,
SUNDIALS::SundialsPreconditioner<VectorType> &prec,
- VectorType & x,
- const VectorType & b,
+ VectorType &x,
+ const VectorType &b,
double tol) {
ReductionControl control;
SolverCG<VectorType> solver_cg(control);
ode.mass_times_vector = [&](const double t,
const VectorType &v,
- VectorType & Mv) { M.vmult(Mv, v); };
+ VectorType &Mv) { M.vmult(Mv, v); };
ode.output_step =
};
ode.jacobian_times_vector = [&](const VectorType &v,
- VectorType & Jv,
+ VectorType &Jv,
double t,
const VectorType &y,
const VectorType &fy) { K.vmult(Jv, v); };
};
- ode.solve_mass = [&](SUNDIALS::SundialsOperator<VectorType> & op,
+ ode.solve_mass = [&](SUNDIALS::SundialsOperator<VectorType> &op,
SUNDIALS::SundialsPreconditioner<VectorType> &prec,
- VectorType & x,
- const VectorType & b,
+ VectorType &x,
+ const VectorType &b,
double tol) {
ReductionControl control;
SolverCG<VectorType> solver_cg(control);
ode.mass_times_vector = [&](const double t,
const VectorType &v,
- VectorType & Mv) { M.vmult(Mv, v); };
+ VectorType &Mv) { M.vmult(Mv, v); };
ode.output_step =
};
ode.jacobian_times_vector = [&](const VectorType &v,
- VectorType & Jv,
+ VectorType &Jv,
double t,
const VectorType &y,
const VectorType &fy) { K.vmult(Jv, v); };
ode.solve_linearized_system =
- [&](SUNDIALS::SundialsOperator<VectorType> & op,
+ [&](SUNDIALS::SundialsOperator<VectorType> &op,
SUNDIALS::SundialsPreconditioner<VectorType> &prec,
- VectorType & x,
- const VectorType & b,
+ VectorType &x,
+ const VectorType &b,
double tol) {
ReductionControl control;
SolverCG<VectorType> solver_cg(control);
ode.mass_times_vector = [&](const double t,
const VectorType &v,
- VectorType & Mv) { M.vmult(Mv, v); };
+ VectorType &Mv) { M.vmult(Mv, v); };
ode.output_step =
time_stepper.residual = [&](const double t,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res) {
+ VectorType &res) {
res = y_dot;
A.vmult_add(res, y);
};
};
time_stepper.output_step = [&](const double t,
- const VectorType & sol,
- const VectorType & sol_dot,
+ const VectorType &sol,
+ const VectorType &sol_dot,
const unsigned int step_number) {
deallog << t << ' ' << sol[0] << ' ' << sol[1] << ' ' << sol_dot[0] << ' '
<< sol_dot[1] << std::endl;
time_stepper.residual = [&](const double t,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res) {
+ VectorType &res) {
res = y_dot;
A.vmult_add(res, y);
};
};
time_stepper.output_step = [&](const double t,
- const VectorType & sol,
- const VectorType & sol_dot,
+ const VectorType &sol,
+ const VectorType &sol_dot,
const unsigned int step_number) {
deallog << t << ' ' << sol[0] << ' ' << sol[1] << ' ' << sol_dot[0] << ' '
<< sol_dot[1] << std::endl;
time_stepper.residual = [&](const double t,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res) {
+ VectorType &res) {
res[0] = y_dot[0] + kappa * y[0];
};
};
time_stepper.output_step = [&](const double t,
- const VectorType & sol,
- const VectorType & sol_dot,
+ const VectorType &sol,
+ const VectorType &sol_dot,
const unsigned int step_number) {
deallog << "Intermediate output:" << std::endl;
deallog << " t =" << t << std::endl;
time_stepper.residual = [&](const double t,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res) {
+ VectorType &res) {
deallog << "Evaluating residual at t=" << t << std::endl;
if (t > last_residual_eval_time + 0.1)
};
time_stepper.output_step = [&](const double t,
- const VectorType & sol,
- const VectorType & sol_dot,
+ const VectorType &sol,
+ const VectorType &sol_dot,
const unsigned int step_number) {
deallog << "Intermediate output:" << std::endl;
deallog << " t =" << t << std::endl;
time_stepper.residual = [&](const double t,
const VectorType &y,
const VectorType &y_dot,
- VectorType & res) {
+ VectorType &res) {
deallog << "Evaluating residual at t=" << t << std::endl;
if (t > last_residual_eval_time + 0.1)
};
time_stepper.output_step = [&](const double t,
- const VectorType & sol,
- const VectorType & sol_dot,
+ const VectorType &sol,
+ const VectorType &sol_dot,
const unsigned int step_number) {
deallog << "Intermediate output:" << std::endl;
deallog << " t =" << t << std::endl;
kinsol.solve_with_jacobian = [&J_inverse](const VectorType &rhs,
- VectorType & dst,
+ VectorType &dst,
const double /*tolerance*/) {
deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1]
<< ')' << std::endl;
kinsol.solve_with_jacobian = [&J_inverse](const VectorType &rhs,
- VectorType & dst,
+ VectorType &dst,
const double /*tolerance*/) {
deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1]
<< ')' << std::endl;
kinsol.solve_with_jacobian = [&](const VectorType &rhs,
- VectorType & dst,
+ VectorType &dst,
double) { dst[0] = J_inverse * rhs[0]; };
VectorType v(N);
kinsol.solve_with_jacobian = [&](const VectorType &rhs,
- VectorType & dst,
+ VectorType &dst,
double) { dst[0] = J_inverse * rhs[0]; };
VectorType v(N);
void
kinsol_info_callback(const char *module,
const char *function,
- char * msg,
- void * ih_data)
+ char *msg,
+ void *ih_data)
{
(void)ih_data;
deallog << "KINSOL info: " << module << ":" << function << ": " << msg
setup_system(const bool initial_step);
void
solve(const Vector<double> &rhs,
- Vector<double> & solution,
+ Vector<double> &solution,
const double tolerance);
void
refine_mesh();
compute_and_factorize_jacobian(const Vector<double> &evaluation_point);
void
compute_residual(const Vector<double> &evaluation_point,
- Vector<double> & residual);
+ Vector<double> &residual);
Triangulation<dim> triangulation;
void
MinimalSurfaceProblem<dim>::compute_residual(
const Vector<double> &evaluation_point,
- Vector<double> & residual)
+ Vector<double> &residual)
{
residual = 0.0;
template <int dim>
void
MinimalSurfaceProblem<dim>::solve(const Vector<double> &rhs,
- Vector<double> & solution,
+ Vector<double> &solution,
const double /*tolerance*/)
{
jacobian_matrix_factorization->vmult(solution, rhs);
nonlinear_solver.residual =
[&](const Vector<double> &evaluation_point,
- Vector<double> & residual) {
+ Vector<double> &residual) {
compute_residual(evaluation_point, residual);
};
};
nonlinear_solver.solve_with_jacobian = [&](const Vector<double> &rhs,
- Vector<double> & dst,
+ Vector<double> &dst,
const double tolerance) {
solve(rhs, dst, tolerance);
};
}
SE::RCP<const SE::Basic>
-make_symengine_rcp(const std::string & name,
+make_symengine_rcp(const std::string &name,
const std::vector<SE::RCP<const SE::Basic>> &args)
{
return SE::function_symbol(name, args);
SE::RCP<const SE::Symbol> H_sat_0 = SE::symbol("H_sat_0");
SE::vec_basic independents = {H_0,
- H_2,
- H_1,
- mu_r,
- mu_e,
- C_22,
- C_12,
- C_11,
- C_00,
- C_01,
- C_02,
- kappa,
- sf_sat_0,
- H_sat_0};
+ H_2,
+ H_1,
+ mu_r,
+ mu_e,
+ C_22,
+ C_12,
+ C_11,
+ C_00,
+ C_01,
+ C_02,
+ kappa,
+ sf_sat_0,
+ H_sat_0};
std::vector<double> independents_vals = {0,
75000,
0,
static NumberType
psi(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * std::pow(v_dot_v(v), 3) * std::pow(s, sf);
};
static Tensor<2, dim, NumberType>
dpsi_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 1) * ddet_t_dt(t) *
std::pow(v_dot_v(v), 3) * std::pow(s, sf);
static Tensor<1, dim, NumberType>
dpsi_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * 3.0 * std::pow(v_dot_v(v), 2) *
dv_dot_v_dv(v) * std::pow(s, sf);
static NumberType
dpsi_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * std::pow(v_dot_v(v), 3) * sf *
std::pow(s, sf - 1.0);
static Tensor<4, dim, NumberType>
d2psi_dt_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(v_dot_v(v), 3) *
(std::pow(det_t(t), 0) * outer_product(ddet_t_dt(t), ddet_t_dt(t)) +
static Tensor<3, dim, NumberType>
d2psi_dv_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 1) * 3.0 * std::pow(v_dot_v(v), 2) *
outer_product(ddet_t_dt(t), dv_dot_v_dv(v)) * std::pow(s, sf);
static Tensor<2, dim, NumberType>
d2psi_ds_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 1) * ddet_t_dt(t) *
std::pow(v_dot_v(v), 3) * sf * std::pow(s, sf - 1.0);
static Tensor<3, dim, NumberType>
d2psi_dt_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 1) * 3.0 * std::pow(v_dot_v(v), 2) *
outer_product(dv_dot_v_dv(v), ddet_t_dt(t)) * std::pow(s, sf);
static Tensor<2, dim, NumberType>
d2psi_dv_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * 3.0 *
(2.0 * std::pow(v_dot_v(v), 1) *
static Tensor<1, dim, NumberType>
d2psi_ds_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * 3.0 * std::pow(v_dot_v(v), 2) *
dv_dot_v_dv(v) * sf * std::pow(s, sf - 1.0);
static Tensor<2, dim, NumberType>
d2psi_dt_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 1) * ddet_t_dt(t) *
std::pow(v_dot_v(v), 3) * sf * std::pow(s, sf - 1.0);
static Tensor<1, dim, NumberType>
d2psi_dv_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * 3.0 * std::pow(v_dot_v(v), 2) *
dv_dot_v_dv(v) * sf * std::pow(s, sf - 1.0);
static NumberType
d2psi_ds_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * std::pow(v_dot_v(v), 3) * sf * (sf - 1.0) *
std::pow(s, sf - 2.0);
}
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<0, dim, NumberType> &val)
{
stream << name << ": " << val << std::endl;
}
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<1, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
}
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<2, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
}
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<3, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
}
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<4, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
void
evaluate_SD_SD_stored_symbols_optimisation(const Tensor<2, dim> &t,
const Tensor<1, dim> &v,
- const double & s)
+ const double &s)
{
using SDNumberType = SD::Expression;
static NumberType
psi(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * std::pow(v_dot_v(v), 3) * std::pow(s, sf);
};
static Tensor<2, dim, NumberType>
dpsi_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 1) * ddet_t_dt(t) *
std::pow(v_dot_v(v), 3) * std::pow(s, sf);
static Tensor<1, dim, NumberType>
dpsi_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * 3.0 * std::pow(v_dot_v(v), 2) *
dv_dot_v_dv(v) * std::pow(s, sf);
static NumberType
dpsi_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * std::pow(v_dot_v(v), 3) * sf *
std::pow(s, sf - 1.0);
static Tensor<4, dim, NumberType>
d2psi_dt_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(v_dot_v(v), 3) *
(std::pow(det_t(t), 0) * outer_product(ddet_t_dt(t), ddet_t_dt(t)) +
static Tensor<3, dim, NumberType>
d2psi_dv_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 1) * 3.0 * std::pow(v_dot_v(v), 2) *
outer_product(ddet_t_dt(t), dv_dot_v_dv(v)) * std::pow(s, sf);
static Tensor<2, dim, NumberType>
d2psi_ds_dt(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 1) * ddet_t_dt(t) *
std::pow(v_dot_v(v), 3) * sf * std::pow(s, sf - 1.0);
static Tensor<3, dim, NumberType>
d2psi_dt_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 1) * 3.0 * std::pow(v_dot_v(v), 2) *
outer_product(dv_dot_v_dv(v), ddet_t_dt(t)) * std::pow(s, sf);
static Tensor<2, dim, NumberType>
d2psi_dv_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * 3.0 *
(2.0 * std::pow(v_dot_v(v), 1) *
static Tensor<1, dim, NumberType>
d2psi_ds_dv(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * 3.0 * std::pow(v_dot_v(v), 2) *
dv_dot_v_dv(v) * sf * std::pow(s, sf - 1.0);
static Tensor<2, dim, NumberType>
d2psi_dt_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 1) * ddet_t_dt(t) *
std::pow(v_dot_v(v), 3) * sf * std::pow(s, sf - 1.0);
static Tensor<1, dim, NumberType>
d2psi_dv_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * 3.0 * std::pow(v_dot_v(v), 2) *
dv_dot_v_dv(v) * sf * std::pow(s, sf - 1.0);
static NumberType
d2psi_ds_ds(const Tensor<2, dim, NumberType> &t,
const Tensor<1, dim, NumberType> &v,
- const NumberType & s)
+ const NumberType &s)
{
return std::pow(det_t(t), 2) * std::pow(v_dot_v(v), 3) * sf * (sf - 1.0) *
std::pow(s, sf - 2.0);
void
evaluate_SD_SD_stored_symbols_optimisation(const Tensor<2, dim> &t,
const Tensor<1, dim> &v,
- const double & s)
+ const double &s)
{
using SDNumberType = SD::Expression;
static const SymmetricTensor<4, dim> dev_P;
};
template <int dim>
- const SymmetricTensor<2, dim>
- StandardTensors<dim>::I = unit_symmetric_tensor<dim>();
+ const SymmetricTensor<2, dim> StandardTensors<dim>::I =
+ unit_symmetric_tensor<dim>();
template <int dim>
const SymmetricTensor<4, dim> StandardTensors<dim>::IxI = outer_product(I, I);
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::II = identity_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::II =
+ identity_tensor<dim>();
template <int dim>
- const SymmetricTensor<4, dim>
- StandardTensors<dim>::dev_P = deviator_tensor<dim>();
+ const SymmetricTensor<4, dim> StandardTensors<dim>::dev_P =
+ deviator_tensor<dim>();
class Time
{
public:
void
assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const;
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const;
void
copy_local_to_global_K(const PerTaskData_K &data);
void
void
assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const;
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const;
void
copy_local_to_global_rhs(const PerTaskData_RHS &data);
void
void
assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data);
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data);
void
copy_local_to_global_sc(const PerTaskData_SC &data);
void
void
update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
- PerTaskData_UQPH & data);
+ ScratchData_UQPH &scratch,
+ PerTaskData_UQPH &data);
void
copy_local_to_global_UQPH(const PerTaskData_UQPH & /*data*/)
{}
get_error_residual(Errors &error_residual);
void
get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update);
+ Errors &error_update);
std::pair<double, double>
get_error_dilation() const;
double
std::vector<std::vector<Tensor<2, dim>>> grad_Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_K(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, Nx(qf_cell.size(), std::vector<double>(fe_cell.dofs_per_cell))
std::vector<std::vector<double>> Nx;
std::vector<std::vector<SymmetricTensor<2, dim>>> symm_grad_Nx;
ScratchData_RHS(const FiniteElement<dim> &fe_cell,
- const QGauss<dim> & qf_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
- const QGauss<dim - 1> & qf_face,
+ const QGauss<dim - 1> &qf_face,
const UpdateFlags uf_face)
: fe_values_ref(fe_cell, qf_cell, uf_cell)
, fe_face_values_ref(fe_cell, qf_face, uf_face)
template <int dim>
struct Solid<dim>::ScratchData_UQPH
{
- const BlockVector<double> & solution_total;
+ const BlockVector<double> &solution_total;
std::vector<Tensor<2, dim>> solution_grads_u_total;
std::vector<double> solution_values_p_total;
std::vector<double> solution_values_J_total;
FEValues<dim> fe_values_ref;
- ScratchData_UQPH(const FiniteElement<dim> & fe_cell,
- const QGauss<dim> & qf_cell,
+ ScratchData_UQPH(const FiniteElement<dim> &fe_cell,
+ const QGauss<dim> &qf_cell,
const UpdateFlags uf_cell,
const BlockVector<double> &solution_total)
: solution_total(solution_total)
void
Solid<dim>::update_qph_incremental_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_UQPH & scratch,
+ ScratchData_UQPH &scratch,
PerTaskData_UQPH & /*data*/)
{
const std::vector<std::shared_ptr<PointHistory<dim>>> lqph =
template <int dim>
void
Solid<dim>::get_error_update(const BlockVector<double> &newton_update,
- Errors & error_update)
+ Errors &error_update)
{
BlockVector<double> error_ud(dofs_per_block);
for (unsigned int i = 0; i < dof_handler_ref.n_dofs(); ++i)
void
Solid<dim>::assemble_system_tangent_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_K & scratch,
- PerTaskData_K & data) const
+ ScratchData_K &scratch,
+ PerTaskData_K &data) const
{
data.reset();
scratch.reset();
const SymmetricTensor<4, dim> Jc = lqph[q_point]->get_Jc();
const double d2Psi_vol_dJ2 = lqph[q_point]->get_d2Psi_vol_dJ2();
const double det_F = lqph[q_point]->get_det_F();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const std::vector<Tensor<2, dim>> &grad_Nx = scratch.grad_Nx[q_point];
void
Solid<dim>::assemble_system_rhs_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_RHS & scratch,
- PerTaskData_RHS & data) const
+ ScratchData_RHS &scratch,
+ PerTaskData_RHS &data) const
{
data.reset();
scratch.reset();
const double J_tilde = lqph[q_point]->get_J_tilde();
const double p_tilde = lqph[q_point]->get_p_tilde();
const double dPsi_vol_dJ = lqph[q_point]->get_dPsi_vol_dJ();
- const std::vector<double> & N = scratch.Nx[q_point];
+ const std::vector<double> &N = scratch.Nx[q_point];
const std::vector<SymmetricTensor<2, dim>> &symm_grad_Nx =
scratch.symm_grad_Nx[q_point];
const double JxW = scratch.fe_values_ref.JxW(q_point);
void
Solid<dim>::assemble_sc_one_cell(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- ScratchData_SC & scratch,
- PerTaskData_SC & data)
+ ScratchData_SC &scratch,
+ PerTaskData_SC &data)
{
data.reset();
scratch.reset();
const Vector<double> &f_u = system_rhs.block(u_dof);
const Vector<double> &f_p = system_rhs.block(p_dof);
const Vector<double> &f_J = system_rhs.block(J_dof);
- Vector<double> & d_u = newton_update.block(u_dof);
- Vector<double> & d_p = newton_update.block(p_dof);
- Vector<double> & d_J = newton_update.block(J_dof);
+ Vector<double> &d_u = newton_update.block(u_dof);
+ Vector<double> &d_p = newton_update.block(p_dof);
+ Vector<double> &d_J = newton_update.block(J_dof);
const auto K_uu =
linear_operator(tangent_matrix.block(u_dof, u_dof));
const auto K_up =
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<0, dim, NumberType> &val)
{
stream << name << ": " << val << std::endl;
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<1, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<2, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const SymmetricTensor<2, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<3, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<4, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const SymmetricTensor<4, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
static NumberType
psi(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return std::pow(det_t(st), 2) * std::pow(det_t(t), 2) *
std::pow(v_squ(v), 3) * std::pow(s, sf);
static SymmetricTensor<2, dim, NumberType>
dpsi_dst(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(st), 1) * ddet_t_dt(st) *
std::pow(det_t(t), 2) * std::pow(v_squ(v), 3) * std::pow(s, sf);
static Tensor<2, dim, NumberType>
dpsi_dt(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(st), 2) * std::pow(det_t(t), 1) * ddet_t_dt(t) *
std::pow(v_squ(v), 3) * std::pow(s, sf);
static Tensor<1, dim, NumberType>
dpsi_dv(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return std::pow(det_t(st), 2) * std::pow(det_t(t), 2) * 3.0 *
std::pow(v_squ(v), 2) * dv_squ_dv(v) * std::pow(s, sf);
static NumberType
dpsi_ds(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return std::pow(det_t(st), 2) * std::pow(det_t(t), 2) *
std::pow(v_squ(v), 3) * sf * std::pow(s, sf - 1.0);
static SymmetricTensor<4, dim, NumberType>
d2psi_dst_x_dst(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 2) * std::pow(v_squ(v), 3) *
(std::pow(det_t(st), 0) *
static Tensor<4, dim, NumberType>
d2psi_dst_x_dt(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 4.0 * std::pow(det_t(st), 1) * std::pow(det_t(t), 1) *
outer_product(Tensor<2, dim, NumberType>(ddet_t_dt(st)),
static Tensor<3, dim, NumberType>
d2psi_dst_x_dv(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 2) * std::pow(det_t(st), 1) * 3.0 *
std::pow(v_squ(v), 2) *
static SymmetricTensor<2, dim, NumberType>
d2psi_dst_x_ds(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(st), 1) * ddet_t_dt(st) *
std::pow(det_t(t), 2) * std::pow(v_squ(v), 3) * sf *
static Tensor<4, dim, NumberType>
d2psi_dt_x_dst(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 4.0 * std::pow(det_t(st), 1) * std::pow(det_t(t), 1) *
outer_product(ddet_t_dt(t),
static Tensor<4, dim, NumberType>
d2psi_dt_x_dt(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(st), 2) * std::pow(v_squ(v), 3) *
(pow(det_t(t), 0) * outer_product(ddet_t_dt(t), ddet_t_dt(t)) +
static Tensor<3, dim, NumberType>
d2psi_dt_x_dv(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(st), 2) * std::pow(det_t(t), 1) * 3.0 *
std::pow(v_squ(v), 2) * outer_product(ddet_t_dt(t), dv_squ_dv(v)) *
static Tensor<2, dim, NumberType>
d2psi_dt_x_ds(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(st), 2) * std::pow(det_t(t), 1) * ddet_t_dt(t) *
std::pow(v_squ(v), 3) * sf * std::pow(s, sf - 1.0);
static Tensor<3, dim, NumberType>
d2psi_dv_x_dst(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(t), 2) * std::pow(det_t(st), 1) * 3.0 *
std::pow(v_squ(v), 2) *
static Tensor<3, dim, NumberType>
d2psi_dv_x_dt(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(st), 2) * std::pow(det_t(t), 1) * 3.0 *
std::pow(v_squ(v), 2) * outer_product(dv_squ_dv(v), ddet_t_dt(t)) *
static Tensor<2, dim, NumberType>
d2psi_dv_x_dv(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return std::pow(det_t(st), 2) * std::pow(det_t(t), 2) * 3.0 *
(2.0 * std::pow(v_squ(v), 1) *
static Tensor<1, dim, NumberType>
d2psi_dv_x_ds(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return std::pow(det_t(st), 2) * std::pow(det_t(t), 2) * 3.0 *
std::pow(v_squ(v), 2) * dv_squ_dv(v) * sf * std::pow(s, sf - 1.0);
static SymmetricTensor<2, dim, NumberType>
d2psi_ds_x_dst(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * ddet_t_dt(st) * std::pow(det_t(t), 2) *
std::pow(det_t(st), 1) * std::pow(v_squ(v), 3) * sf *
static Tensor<2, dim, NumberType>
d2psi_ds_x_dt(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return 2.0 * std::pow(det_t(st), 2) * std::pow(det_t(t), 1) * ddet_t_dt(t) *
std::pow(v_squ(v), 3) * sf * std::pow(s, sf - 1.0);
static Tensor<1, dim, NumberType>
d2psi_ds_x_dv(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return std::pow(det_t(st), 2) * std::pow(det_t(t), 2) * 3.0 *
std::pow(v_squ(v), 2) * dv_squ_dv(v) * sf * std::pow(s, sf - 1.0);
static NumberType
d2psi_ds_x_ds(const SymmetricTensor<2, dim, NumberType> &st,
- const Tensor<2, dim, NumberType> & t,
- const Tensor<1, dim, NumberType> & v,
- const NumberType & s)
+ const Tensor<2, dim, NumberType> &t,
+ const Tensor<1, dim, NumberType> &v,
+ const NumberType &s)
{
return std::pow(det_t(st), 2) * std::pow(det_t(t), 2) *
std::pow(v_squ(v), 3) * sf * (sf - 1.0) * std::pow(s, sf - 2.0);
}
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<0, dim, NumberType> &val)
{
stream << name << ": " << val << std::endl;
}
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<1, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
}
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<2, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
}
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<3, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
}
template <typename Stream, int dim, typename NumberType>
void
-print(Stream & stream,
- const std::string & name,
+print(Stream &stream,
+ const std::string &name,
const Tensor<4, dim, NumberType> &t)
{
for (unsigned int i = 0; i < dim; ++i)
void
test_symmetric_tensor_tensor_vector_scalar_coupled(
const SymmetricTensor<2, dim, number_t> &st,
- const Tensor<2, dim, number_t> & t,
- const Tensor<1, dim, number_t> & v,
- const number_t & s)
+ const Tensor<2, dim, number_t> &t,
+ const Tensor<1, dim, number_t> &v,
+ const number_t &s)
{
using SDNumberType = SD::Expression;
DEAL_II_CONSTEXPR const SymmetricTensor<2, 3> a = symmetrize(dummy_a);
DEAL_II_CONSTEXPR const auto inverted = invert(a);
constexpr double ref_init[3][3] = {{0., -2., 2.},
- {-2., 5., -2.},
- {2., -2., 0.}};
+ {-2., 5., -2.},
+ {2., -2., 0.}};
constexpr Tensor<2, 3> dummy_ref{ref_init};
DEAL_II_CONSTEXPR const SymmetricTensor<2, 3> ref = symmetrize(dummy_ref);
Assert(inverted == ref, ExcInternalError());
constexpr Tensor<2, 3> a{a_init};
DEAL_II_CONSTEXPR const auto inverted = invert(a);
constexpr double ref_init[3][3] = {{1., 0., 0.},
- {-2., 1., 0.},
- {1., -2., 1}};
+ {-2., 1., 0.},
+ {1., -2., 1}};
constexpr Tensor<2, 3> ref{ref_init};
Assert(inverted == ref, ExcInternalError());
}
template <int, int, typename>
class T3>
void
-test_symm_tensor_contract_3(const T1<rank1, dim, number> & l,
+test_symm_tensor_contract_3(const T1<rank1, dim, number> &l,
const Tensor<rank2, dim, number> &m,
- const T3<rank3, dim, number> & r)
+ const T3<rank3, dim, number> &r)
{
const double res1 = contract3(l, m, r);
const double res2 = contract3(static_cast<Tensor<rank1, dim>>(l),
void
-check(Epetra_FECrsMatrix & mat,
+check(Epetra_FECrsMatrix &mat,
Teuchos::ParameterList ¶meter_list,
- Epetra_FEVector & x1,
- Epetra_FEVector & x2,
- Epetra_FEVector & b)
+ Epetra_FEVector &x1,
+ Epetra_FEVector &x2,
+ Epetra_FEVector &b)
{
int ierr;
{
struct Data
{
Data(const hp::FECollection<dim> &fe,
- const hp::QCollection<dim> & quadrature)
+ const hp::QCollection<dim> &quadrature)
: hp_fe_values(fe,
quadrature,
update_values | update_gradients |
void
local_assemble(const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data);
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
void
LaplaceProblem<dim>::local_assemble(
const typename DoFHandler<dim>::active_cell_iterator &cell,
- Assembly::Scratch::Data<dim> & scratch,
- Assembly::Copy::Data & data)
+ Assembly::Scratch::Data<dim> &scratch,
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
void
local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
- & cell,
+ &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data);
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
LaplaceProblem<dim>::local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data)
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
void
local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
- & cell,
+ &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data);
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
LaplaceProblem<dim>::local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data)
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
void
local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
- & cell,
+ &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data);
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
LaplaceProblem<dim>::local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data)
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
void
local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
- & cell,
+ &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data);
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
LaplaceProblem<dim>::local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data)
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
void
local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
- & cell,
+ &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data);
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
LaplaceProblem<dim>::local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data)
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
void
local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
- & cell,
+ &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data);
+ Assembly::Copy::Data &data);
void
copy_local_to_global(const Assembly::Copy::Data &data);
IndexSet relevant_set;
DoFTools::extract_locally_relevant_dofs(dof_handler, relevant_set);
// TODO: currently no Trilinos version is capable of doing this...
- //#if DEAL_II_TRILINOS_VERSION_GTE(11,14,0)
+ // #if DEAL_II_TRILINOS_VERSION_GTE(11,14,0)
// Cannot pre-build sparsity pattern, Trilinos must provide it...
// csp.reinit(locally_owned, locally_owned, MPI_COMM_WORLD);
- //#else
+ // #else
// OK, Trilinos not new enough - use exactly the same as
// assemble_matrix_parallel_02.cc
csp.reinit(locally_owned, locally_owned, relevant_set, MPI_COMM_WORLD);
- //#endif
+ // #endif
DoFTools::make_sparsity_pattern(dof_handler, csp, constraints, false);
csp.compress();
test_matrix.reinit(csp);
LaplaceProblem<dim>::local_assemble(
const FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> &cell,
Assembly::Scratch::Data<dim> &scratch,
- Assembly::Copy::Data & data)
+ Assembly::Copy::Data &data)
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
void
calculate_flux_terms(
const TriaActiveIterator<DoFCellAccessor<dim, dim, false>> ¤t_cell,
- FEFaceValues<dim> & current_face_values,
+ FEFaceValues<dim> ¤t_face_values,
const TriaIterator<DoFCellAccessor<dim, dim, false>> &neighbor_cell,
FEFaceValuesBase<dim> &neighbor_face_values,
- FullMatrix<double> & current_to_current_flux,
- FullMatrix<double> & current_to_neighbor_flux,
- FullMatrix<double> & neighbor_to_current_flux,
- FullMatrix<double> & neighbor_to_neighbor_flux);
+ FullMatrix<double> ¤t_to_current_flux,
+ FullMatrix<double> ¤t_to_neighbor_flux,
+ FullMatrix<double> &neighbor_to_current_flux,
+ FullMatrix<double> &neighbor_to_neighbor_flux);
const unsigned int n_mpi_processes;
const unsigned int this_mpi_process;
void
AdvectionProblem<dim>::calculate_flux_terms(
const TriaActiveIterator<DoFCellAccessor<dim, dim, false>> ¤t_cell,
- FEFaceValues<dim> & current_face_values,
+ FEFaceValues<dim> ¤t_face_values,
const TriaIterator<DoFCellAccessor<dim, dim, false>> &neighbor_cell,
- FEFaceValuesBase<dim> & neighbor_face_values,
+ FEFaceValuesBase<dim> &neighbor_face_values,
FullMatrix<double> & /*current_to_current_flux*/,
FullMatrix<double> & /*current_to_neighbor_flux*/,
FullMatrix<double> & /*neighbor_to_current_flux*/,
set_ghost.add_range(45, 100);
}
else
- {}
+ {
+ }
auto check = [&](IndexSet &idxset) {
deallog << "IndexSet before size=" << idxset.size() << " values: ";
template <int dim, int spacedim>
void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> & mg_dof,
+reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
MGLevelObject<TrilinosWrappers::MPI::Vector> &v)
{
const dealii::parallel::distributed::Triangulation<dim, spacedim> *tria =
{
public:
bool
- computeF(const Epetra_Vector & x,
- Epetra_Vector & f,
+ computeF(const Epetra_Vector &x,
+ Epetra_Vector &f,
NOX::Epetra::Interface::Required::FillType F) override
{
(void)F;
};
solver.solve_with_jacobian = [&J_inverse](const VectorType &rhs,
- VectorType & dst,
+ VectorType &dst,
const double /*tolerance*/) {
deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1]
<< ')' << std::endl;
};
solver.solve_with_jacobian = [&J_inverse](const VectorType &rhs,
- VectorType & dst,
+ VectorType &dst,
const double /*tolerance*/) {
deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1]
<< ')' << std::endl;
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().degree;
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().degree;
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
{
public:
void
- cell(MeshWorker::DoFInfo<dim> & dinfo,
+ cell(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- boundary(MeshWorker::DoFInfo<dim> & dinfo,
+ boundary(MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const;
void
- face(MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ face(MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const;
};
template <int dim>
void
MatrixIntegrator<dim>::cell(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
LocalIntegrators::Laplace::cell_matrix(dinfo.matrix(0, false).matrix,
template <int dim>
void
MatrixIntegrator<dim>::boundary(
- MeshWorker::DoFInfo<dim> & dinfo,
+ MeshWorker::DoFInfo<dim> &dinfo,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().degree;
template <int dim>
void
MatrixIntegrator<dim>::face(
- MeshWorker::DoFInfo<dim> & dinfo1,
- MeshWorker::DoFInfo<dim> & dinfo2,
+ MeshWorker::DoFInfo<dim> &dinfo1,
+ MeshWorker::DoFInfo<dim> &dinfo2,
typename MeshWorker::IntegrationInfo<dim> &info1,
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
setup_system(const bool initial_step);
void
solve(const Vector<double> &rhs,
- Vector<double> & solution,
+ Vector<double> &solution,
const double tolerance);
void
refine_mesh();
compute_and_factorize_jacobian(const Vector<double> &evaluation_point);
void
compute_residual(const Vector<double> &evaluation_point,
- Vector<double> & residual);
+ Vector<double> &residual);
Triangulation<dim> triangulation;
void
MinimalSurfaceProblem<dim>::compute_residual(
const Vector<double> &evaluation_point,
- Vector<double> & residual)
+ Vector<double> &residual)
{
residual = 0;
template <int dim>
void
MinimalSurfaceProblem<dim>::solve(const Vector<double> &rhs,
- Vector<double> & solution,
+ Vector<double> &solution,
const double /*tolerance*/)
{
jacobian_matrix_factorization->vmult(solution, rhs);
nonlinear_solver.residual =
[&](const Vector<double> &evaluation_point,
- Vector<double> & residual) {
+ Vector<double> &residual) {
compute_residual(evaluation_point, residual);
};
};
nonlinear_solver.solve_with_jacobian = [&](const Vector<double> &rhs,
- Vector<double> & dst,
+ Vector<double> &dst,
const double tolerance) {
solve(rhs, dst, tolerance);
};
template <int dim, typename MatrixType, typename VectorType>
void
-assemble_laplace(MatrixType & B,
- VectorType & bb,
- DoFHandler<dim> & dof_handler,
+assemble_laplace(MatrixType &B,
+ VectorType &bb,
+ DoFHandler<dim> &dof_handler,
FiniteElement<dim> &fe)
{
QGauss<dim> quadrature_formula(2);