--- /dev/null
+Removed: The previously deprecated class hp::DoFHandler has been
+removed, and with it all functions and classes that required the
+template parameter DoFHandlerType.
+<br>
+From now on, use the standard DoFHandler. All hp-functionality has been
+integrated to this one.
+<br>
+(Marc Fehling, Peter Munch, 2022/05/24)
} // namespace distributed
} // namespace parallel
-namespace Legacy
-{
- namespace parallel
- {
- namespace distributed
- {
- /**
- * @deprecated Use dealii::parallel::distributed::SolutionTransfer
- * without the DoFHandlerType template instead.
- */
- template <int dim,
- typename VectorType,
- typename DoFHandlerType = DoFHandler<dim>>
- using SolutionTransfer DEAL_II_DEPRECATED =
- dealii::parallel::distributed::
- SolutionTransfer<dim, VectorType, DoFHandlerType::space_dimension>;
- } // namespace distributed
- } // namespace parallel
-} // namespace Legacy
-
DEAL_II_NAMESPACE_CLOSE
#include <deal.II/grid/tria_accessor.h>
-#include <deal.II/hp/dof_handler.h>
-
DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
#include <boost/container/small_vector.hpp>
DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/hp/dof_handler.h>
-
#include <vector>
DEAL_II_NAMESPACE_OPEN
#include <deal.II/fe/component_mask.h>
-#include <deal.II/hp/dof_handler.h>
-
#include <deal.II/lac/affine_constraints.h>
#include <map>
const number periodicity_factor = 1.);
-
/**
* Insert the (algebraic) constraints due to periodic boundary conditions
* into an AffineConstraints object @p constraints.
std::vector<unsigned int>(),
const number periodicity_factor = 1.);
- /**
- * The same as above.
- *
- * @deprecated Use the function that takes dim and spacedim as template
- * argument.
- */
- template <typename DoFHandlerType, typename number>
- DEAL_II_DEPRECATED void
- make_periodicity_constraints(
- const std::vector<
- GridTools::PeriodicFacePair<typename DoFHandlerType::cell_iterator>>
- & periodic_faces,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask = ComponentMask(),
- const std::vector<unsigned int> &first_vector_components =
- std::vector<unsigned int>(),
- const number periodicity_factor = 1.);
-
/**
const std::vector<typename DoFHandler<dim, spacedim>::active_cell_iterator>
&patch);
- /**
- * The same as above.
- *
- * @deprecated Use the function that takes dim and spacedim as template
- * argument.
- */
- template <typename DoFHandlerType>
- DEAL_II_DEPRECATED std::vector<types::global_dof_index>
- get_dofs_on_patch(
- const std::vector<typename DoFHandlerType::active_cell_iterator> &patch);
-
/**
* Creates a sparsity pattern, which lists
* the degrees of freedom associated to each cell on the given
const std::vector<typename DoFHandler<dim, spacedim>::active_cell_iterator>
&patch);
- /**
- * The same as above.
- *
- * @deprecated Use the function that takes dim and spacedim as template
- * argument.
- */
- template <typename DoFHandlerType>
- DEAL_II_DEPRECATED unsigned int
- count_dofs_on_patch(
- const std::vector<typename DoFHandlerType::active_cell_iterator> &patch);
-
/**
* @}
*/
for (types::global_dof_index i = 0; i < dof_handler.n_dofs(); ++i)
point_to_index_map[support_points[i]] = i;
}
-
-
-
- template <typename DoFHandlerType, typename number>
- inline void
- make_periodicity_constraints(
- const std::vector<
- GridTools::PeriodicFacePair<typename DoFHandlerType::cell_iterator>>
- & periodic_faces,
- AffineConstraints<number> & constraints,
- const ComponentMask & component_mask,
- const std::vector<unsigned int> &first_vector_components,
- const number periodicity_factor)
- {
- make_periodicity_constraints<DoFHandlerType::dimension,
- DoFHandlerType::space_dimension>(
- periodic_faces,
- constraints,
- component_mask,
- first_vector_components,
- periodicity_factor);
- }
-
-
-
- template <typename DoFHandlerType>
- inline std::vector<types::global_dof_index>
- get_dofs_on_patch(
- const std::vector<typename DoFHandlerType::active_cell_iterator> &patch)
- {
- return get_dofs_on_patch<DoFHandlerType::dimension,
- DoFHandlerType::space_dimension>(patch);
- }
-
-
-
- template <typename DoFHandlerType>
- inline unsigned int
- count_dofs_on_patch(
- const std::vector<typename DoFHandlerType::active_cell_iterator> &patch)
- {
- return count_dofs_on_patch<DoFHandlerType::dimension,
- DoFHandlerType::space_dimension>(patch);
- }
} // namespace DoFTools
#endif
virtual std::string
get_name() const = 0;
- /**
- * This operator returns a reference to the present object if the argument
- * given equals to zero. While this does not seem particularly useful, it is
- * helpful in writing code that works with both ::DoFHandler and the hp-
- * version hp::DoFHandler, since one can then write code like this:
- * @code
- * dofs_per_cell =
- * dof_handler->get_fe()[cell->active_fe_index()].n_dofs_per_cell();
- * @endcode
- *
- * This code doesn't work in both situations without the present operator
- * because DoFHandler::get_fe() returns a finite element, whereas
- * hp::DoFHandler::get_fe() returns a collection of finite elements that
- * doesn't offer a <code>dofs_per_cell</code> member variable: one first has
- * to select which finite element to work on, which is done using the
- * operator[]. Fortunately, <code>cell-@>active_fe_index()</code> also works
- * for non-hp-classes and simply returns zero in that case. The present
- * operator[] accepts this zero argument, by returning the finite element
- * with index zero within its collection (that, of course, consists only of
- * the present finite element anyway).
- *
- * @deprecated With DoFHandler::get_fe(int) and the deprecation of the
- * hp::DoFHandler class, there is no more use of this operator.
- */
- DEAL_II_DEPRECATED const FiniteElement<dim, spacedim> &
- operator[](const unsigned int fe_index) const;
-
/**
* @name Shape function access
* @{
//----------------------------------------------------------------------//
-template <int dim, int spacedim>
-inline const FiniteElement<dim, spacedim> &
-FiniteElement<dim, spacedim>::operator[](const unsigned int fe_index) const
-{
- (void)fe_index;
- Assert(fe_index == 0,
- ExcMessage("A fe_index of zero is the only index allowed here"));
- return *this;
-}
-
-
-
template <int dim, int spacedim>
inline std::pair<unsigned int, unsigned int>
FiniteElement<dim, spacedim>::system_to_component_index(
#include <deal.II/base/quadrature.h>
#include <deal.II/base/symmetric_tensor.h>
+#include <deal.II/dofs/dof_handler.h>
+
#include <deal.II/fe/fe.h>
#include <deal.II/fe/fe_nothing.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
#include <deal.II/fe/fe_update_flags.h>
-#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/fe_collection.h>
#include <map>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/hp/dof_handler.h>
-
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/householder.h>
if (dynamic_cast<const parallel::distributed::Triangulation<dim, spacedim>
*>(&dof2.get_triangulation()) != nullptr)
{
- Assert(dof1.get_fe()[0].reference_cell() ==
+ Assert(dof1.get_fe(0).reference_cell() ==
ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
- Assert(dof2.get_fe()[0].reference_cell() ==
+ Assert(dof2.get_fe(0).reference_cell() ==
ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/hp/dof_handler.h>
-
#include <deal.II/lac/affine_constraints.h>
#include <deal.II/lac/block_vector.h>
#include <deal.II/lac/la_parallel_block_vector.h>
/*!@addtogroup mapping */
/*@{*/
-/**
- * @deprecated Use MappingFEField<dim, spacedim, VectorType> instead.
- */
-template <int dim,
- int spacedim = dim,
- typename VectorType = Vector<double>,
- typename DoFHandlerType = void>
-class MappingFEField;
-
-#ifndef DOXYGEN
-// prevent doxygen from complaining about potential recursive class relations
-template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
-class MappingFEField : public MappingFEField<dim, spacedim, VectorType, void>
-{
-public:
- DEAL_II_DEPRECATED
- MappingFEField(const DoFHandlerType &euler_dof_handler,
- const VectorType & euler_vector,
- const ComponentMask & mask = ComponentMask())
- : MappingFEField<dim, spacedim, VectorType, void>(euler_dof_handler,
- euler_vector,
- mask)
- {}
-
- DEAL_II_DEPRECATED
- MappingFEField(const DoFHandlerType & euler_dof_handler,
- const std::vector<VectorType> &euler_vector,
- const ComponentMask & mask = ComponentMask())
- : MappingFEField<dim, spacedim, VectorType, void>(euler_dof_handler,
- euler_vector,
- mask)
- {}
-
- DEAL_II_DEPRECATED
- MappingFEField(const DoFHandlerType & euler_dof_handler,
- const MGLevelObject<VectorType> &euler_vector,
- const ComponentMask & mask = ComponentMask())
- : MappingFEField<dim, spacedim, VectorType, void>(euler_dof_handler,
- euler_vector,
- mask)
- {}
-
- DEAL_II_DEPRECATED
- MappingFEField(
- const MappingFEField<dim, spacedim, VectorType, DoFHandlerType> &mapping)
- : MappingFEField<dim, spacedim, VectorType, void>(mapping)
- {}
-};
-#endif // DOXYGEN
-
/**
* The MappingFEField is a generalization of the MappingQEulerian class, for
* arbitrary vector finite elements. The two main differences are that this
* MappingFEField<dim,spacedim> map(dhq, eulerq, mask);
* @endcode
*/
-template <int dim, int spacedim, typename VectorType>
-class MappingFEField<dim, spacedim, VectorType, void>
- : public Mapping<dim, spacedim>
+template <int dim, int spacedim = dim, typename VectorType = Vector<double>>
+class MappingFEField : public Mapping<dim, spacedim>
{
public:
/**
/**
* Copy constructor.
*/
- MappingFEField(
- const MappingFEField<dim, spacedim, VectorType, void> &mapping);
+ MappingFEField(const MappingFEField<dim, spacedim, VectorType> &mapping);
/**
* Return a pointer to a copy of the present object. The caller of this copy
/**
* Reference to the vector of shifts.
*/
- std::vector<SmartPointer<const VectorType,
- MappingFEField<dim, spacedim, VectorType, void>>>
+ std::vector<
+ SmartPointer<const VectorType, MappingFEField<dim, spacedim, VectorType>>>
euler_vector;
/**
* Pointer to the DoFHandler to which the mapping vector is associated.
*/
SmartPointer<const DoFHandler<dim, spacedim>,
- MappingFEField<dim, spacedim, VectorType, void>>
+ MappingFEField<dim, spacedim, VectorType>>
euler_dof_handler;
private:
void
update_internal_dofs(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const typename MappingFEField<dim, spacedim, VectorType, void>::InternalData
+ const typename MappingFEField<dim, spacedim, VectorType>::InternalData
&data) const;
/**
virtual void
compute_shapes_virtual(
const std::vector<Point<dim>> &unit_points,
- typename MappingFEField<dim, spacedim, VectorType, void>::InternalData
- &data) const;
+ typename MappingFEField<dim, spacedim, VectorType>::InternalData &data)
+ const;
/*
* Which components to use for the mapping.
// Declare other MappingFEField classes friends.
- template <int, int, class, class>
+ template <int, int, class>
friend class MappingFEField;
};
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/hp/dof_handler.h>
-
#include <deal.II/lac/la_parallel_vector.h>
#include <deal.II/lac/la_vector.h>
#include <deal.II/lac/petsc_vector.h>
+++ /dev/null
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2005 - 2021 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-#ifndef dealii_hp_dof_handler_h
-#define dealii_hp_dof_handler_h
-
-#include <deal.II/dofs/dof_handler.h>
-
-DEAL_II_NAMESPACE_OPEN
-
-namespace hp
-{
- /**
- * Manage the distribution and numbering of the degrees of freedom for hp-
- * FEM algorithms. This class satisfies the
- * @ref ConceptMeshType "MeshType concept"
- * requirements.
- *
- * The purpose of this class is to allow for an enumeration of degrees of
- * freedom in the same way as the ::DoFHandler class, but it allows to use a
- * different finite element on every cell. To this end, one assigns an
- * <code>active_fe_index</code> to every cell that indicates which element
- * within a collection of finite elements (represented by an object of type
- * hp::FECollection) is the one that lives on this cell. The class then
- * enumerates the degree of freedom associated with these finite elements on
- * each cell of a triangulation and, if possible, identifies degrees of
- * freedom at the interfaces of cells if they match. If neighboring cells
- * have degrees of freedom along the common interface that do not immediate
- * match (for example, if you have $Q_2$ and $Q_3$ elements meeting at a
- * common face), then one needs to compute constraints to ensure that the
- * resulting finite element space on the mesh remains conforming.
- *
- * The whole process of working with objects of this type is explained in
- * step-27. Many of the algorithms this class implements are described in
- * the
- * @ref hp_paper "hp-paper".
- *
- *
- * <h3>Active FE indices and their behavior under mesh refinement</h3>
- *
- * The typical workflow for using this class is to create a mesh, assign an
- * active FE index to every active cell, calls
- * hp::DoFHandler::distribute_dofs(), and then assemble a linear system and
- * solve a problem on this finite element space. However, one can skip
- * assigning active FE indices upon mesh refinement in certain
- * circumstances. In particular, the following rules apply:
- * - Upon mesh refinement, child cells inherit the active FE index of
- * the parent.
- * - When coarsening cells, the (now active) parent cell will be assigned
- * an active FE index that is determined from its (no longer active)
- * children, following the FiniteElementDomination logic: Out of the set of
- * elements previously assigned to the former children, we choose the one
- * dominated by all children for the parent cell. If none was found, we pick
- * the most dominant element in the whole collection that is dominated by
- * all former children. See hp::FECollection::find_dominated_fe_extended()
- * for further information on this topic.
- *
- * @note Finite elements need to be assigned to each cell by either calling
- * set_fe() or distribute_dofs() first to make this functionality available.
- *
- *
- * <h3>Active FE indices and parallel meshes</h3>
- *
- * When this class is used with either a parallel::shared::Triangulation
- * or a parallel::distributed::Triangulation, you can only set active
- * FE indices on cells that are locally owned,
- * using a call such as <code>cell-@>set_active_fe_index(...)</code>.
- * On the other hand, setting the active FE index on ghost
- * or artificial cells is not allowed.
- *
- * Ghost cells do acquire the information what element
- * is active on them, however: whenever
- * you call hp::DoFHandler::distribute_dofs(), all processors that
- * participate in the parallel mesh exchange information in such a way
- * that the active FE index on ghost cells equals the active FE index
- * that was set on that processor that owned that particular ghost cell.
- * Consequently, one can <i>query</i> the @p active_fe_index on ghost
- * cells, just not set it by hand.
- *
- * On artificial cells, no information is available about the
- * @p active_fe_index used there. That's because we don't even know
- * whether these cells exist at all, and even if they did, the
- * current processor does not know anything specific about them.
- * See
- * @ref GlossArtificialCell "the glossary entry on artificial cells"
- * for more information.
- *
- * During refinement and coarsening, information about the @p active_fe_index
- * of each cell will be automatically transferred.
- *
- * However, using a parallel::distributed::Triangulation with an
- * hp::DoFHandler requires additional attention during serialization, since no
- * information on active FE indices will be automatically transferred. This
- * has to be done manually using the
- * prepare_for_serialization_of_active_fe_indices() and
- * deserialize_active_fe_indices() functions. The former has to be called
- * before parallel::distributed::Triangulation::save() is invoked, and the
- * latter needs to be run after parallel::distributed::Triangulation::load().
- * If further data will be attached to the triangulation via the
- * parallel::distributed::CellDataTransfer,
- * parallel::distributed::SolutionTransfer, or Particles::ParticleHandler
- * classes, all corresponding preparation and deserialization function calls
- * need to happen in the same order. Consult the documentation of
- * parallel::distributed::SolutionTransfer for more information.
- *
- *
- * @ingroup dofs
- *
- * @deprecated The basic dealii::DoFHandler is capable of hp-adaptation now.
- */
- template <int dim, int spacedim = dim>
- using DoFHandler DEAL_II_DEPRECATED = dealii::DoFHandler<dim, spacedim>;
-} // namespace hp
-
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
#include <deal.II/fe/mapping.h>
#include <deal.II/fe/mapping_q1.h>
-#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/mapping_collection.h>
#include <deal.II/hp/q_collection.h>
const std::vector<QuadratureType> & quad,
const AdditionalData &additional_data = AdditionalData());
- /**
- * Initializes the data structures. Same as above, but using DoFHandlerType.
- *
- * @deprecated Use the overload taking a DoFHandler object instead.
- */
- template <typename QuadratureType,
- typename number2,
- typename DoFHandlerType,
- typename MappingType>
- DEAL_II_DEPRECATED void
- reinit(const MappingType & mapping,
- const std::vector<const DoFHandlerType *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const std::vector<QuadratureType> & quad,
- const AdditionalData &additional_data = AdditionalData());
-
/**
* Initializes the data structures. Same as above, but using a $Q_1$
* mapping.
const std::vector<QuadratureType> & quad,
const AdditionalData &additional_data = AdditionalData());
- /**
- * Initializes the data structures. Same as above, but using DoFHandlerType.
- *
- * @deprecated Use the overload taking a DoFHandler object instead.
- */
- template <typename QuadratureType, typename number2, typename DoFHandlerType>
- DEAL_II_DEPRECATED void
- reinit(const std::vector<const DoFHandlerType *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const std::vector<QuadratureType> & quad,
- const AdditionalData &additional_data = AdditionalData());
-
/**
* Initializes the data structures. Same as before, but now the index set
* description of the locally owned range of degrees of freedom is taken
const QuadratureType & quad,
const AdditionalData &additional_data = AdditionalData());
- /**
- * Initializes the data structures. Same as above, but using DoFHandlerType.
- *
- * @deprecated Use the overload taking a DoFHandler object instead.
- */
- template <typename QuadratureType,
- typename number2,
- typename DoFHandlerType,
- typename MappingType>
- DEAL_II_DEPRECATED void
- reinit(const MappingType & mapping,
- const std::vector<const DoFHandlerType *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const QuadratureType & quad,
- const AdditionalData &additional_data = AdditionalData());
-
/**
* Initializes the data structures. Same as above, but using a $Q_1$
* mapping.
const QuadratureType & quad,
const AdditionalData &additional_data = AdditionalData());
- /**
- * Initializes the data structures. Same as above, but using DoFHandlerType.
- *
- * @deprecated Use the overload taking a DoFHandler object instead.
- */
- template <typename QuadratureType, typename number2, typename DoFHandlerType>
- DEAL_II_DEPRECATED void
- reinit(const std::vector<const DoFHandlerType *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const QuadratureType & quad,
- const AdditionalData &additional_data = AdditionalData());
-
/**
* Copy function. Creates a deep copy of all data structures. It is usually
* enough to keep the data for different operations once, so this function
const DoFHandler<dim> &
get_dof_handler(const unsigned int dof_handler_index = 0) const;
- /**
- * Return the DoFHandler with the index as given to the respective
- * `std::vector` argument in the reinit() function. Note that if you want to
- * call this function with a template parameter different than the default
- * one, you will need to use the `template` before the function call, i.e.,
- * you will have something like `matrix_free.template
- * get_dof_handler<hp::DoFHandler<dim>>()`.
- *
- * @deprecated Use the non-templated equivalent of this function.
- */
- template <typename DoFHandlerType>
- DEAL_II_DEPRECATED const DoFHandlerType &
- get_dof_handler(const unsigned int dof_handler_index = 0) const;
-
/**
* Return the cell iterator in deal.II speak to a given cell batch
* (populating several lanes in a VectorizedArray) and the lane index within
-template <int dim, typename Number, typename VectorizedArrayType>
-template <typename QuadratureType,
- typename number2,
- typename DoFHandlerType,
- typename MappingType>
-void
-MatrixFree<dim, Number, VectorizedArrayType>::reinit(
- const MappingType & mapping,
- const std::vector<const DoFHandlerType *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const std::vector<QuadratureType> & quad,
- const AdditionalData & additional_data)
-{
- static_assert(dim == DoFHandlerType::dimension,
- "Dimension dim not equal to DoFHandlerType::dimension.");
-
- std::vector<const DoFHandler<dim> *> dof_handlers;
-
- for (const auto dh : dof_handler)
- dof_handlers.push_back(dh);
-
- this->reinit(mapping, dof_handlers, constraint, quad, additional_data);
-}
-
-
-
template <int dim, typename Number, typename VectorizedArrayType>
template <typename QuadratureType, typename number2>
void
-template <int dim, typename Number, typename VectorizedArrayType>
-template <typename QuadratureType, typename number2, typename DoFHandlerType>
-void
-MatrixFree<dim, Number, VectorizedArrayType>::reinit(
- const std::vector<const DoFHandlerType *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const std::vector<QuadratureType> & quad,
- const AdditionalData & additional_data)
-{
- static_assert(dim == DoFHandlerType::dimension,
- "Dimension dim not equal to DoFHandlerType::dimension.");
-
- std::vector<const DoFHandler<dim> *> dof_handlers;
-
- for (const auto dh : dof_handler)
- dof_handlers.push_back(dh);
-
- this->reinit(dof_handlers, constraint, quad, additional_data);
-}
-
-
-
template <int dim, typename Number, typename VectorizedArrayType>
template <typename QuadratureType, typename number2, typename MappingType>
void
-template <int dim, typename Number, typename VectorizedArrayType>
-template <typename QuadratureType,
- typename number2,
- typename DoFHandlerType,
- typename MappingType>
-void
-MatrixFree<dim, Number, VectorizedArrayType>::reinit(
- const MappingType & mapping,
- const std::vector<const DoFHandlerType *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const QuadratureType & quad,
- const AdditionalData & additional_data)
-{
- static_assert(dim == DoFHandlerType::dimension,
- "Dimension dim not equal to DoFHandlerType::dimension.");
-
- std::vector<const DoFHandler<dim> *> dof_handlers;
-
- for (const auto dh : dof_handler)
- dof_handlers.push_back(dh);
-
- this->reinit(mapping, dof_handlers, constraint, quad, additional_data);
-}
-
-
-
-template <int dim, typename Number, typename VectorizedArrayType>
-template <typename QuadratureType, typename number2, typename DoFHandlerType>
-void
-MatrixFree<dim, Number, VectorizedArrayType>::reinit(
- const std::vector<const DoFHandlerType *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const QuadratureType & quad,
- const AdditionalData & additional_data)
-{
- static_assert(dim == DoFHandlerType::dimension,
- "Dimension dim not equal to DoFHandlerType::dimension.");
-
- std::vector<const DoFHandler<dim> *> dof_handlers;
-
- for (const auto dh : dof_handler)
- dof_handlers.push_back(dh);
-
- this->reinit(dof_handlers, constraint, quad, additional_data);
-}
-
-
-
// ------------------------------ implementation of loops --------------------
// internal helper functions that define how to call MPI data exchange
-template <int dim, typename Number, typename VectorizedArrayType>
-template <typename DoFHandlerType>
-const DoFHandlerType &
-MatrixFree<dim, Number, VectorizedArrayType>::get_dof_handler(
- const unsigned int dof_handler_index) const
-{
- AssertIndexRange(dof_handler_index, n_components());
-
- auto dh =
- dynamic_cast<const DoFHandlerType *>(&*dof_handlers[dof_handler_index]);
- Assert(dh != nullptr, ExcNotInitialized());
-
- return *dh;
-}
-
-
-
template <int dim, typename Number, typename VectorizedArrayType>
typename DoFHandler<dim>::cell_iterator
MatrixFree<dim, Number, VectorizedArrayType>::get_cell_iterator(
#include <deal.II/grid/filtered_iterator.h>
#include <deal.II/grid/tria_description.h>
-#include <deal.II/hp/dof_handler.h>
-
#include <deal.II/matrix_free/evaluation_kernels.h>
#include <deal.II/matrix_free/evaluation_template_factory.h>
#include <deal.II/matrix_free/tensor_product_kernels.h>
const CurvedCellRegion curved_cell_region);
};
-namespace Legacy
-{
- /**
- * @deprecated Use dealii::DataOut without the DoFHandlerType template
- * instead.
- */
- template <int dim, typename DoFHandlerType = DoFHandler<dim>>
- using DataOut DEAL_II_DEPRECATED =
- dealii::DataOut<dim, DoFHandlerType::space_dimension>;
-} // namespace Legacy
-
DEAL_II_NAMESPACE_CLOSE
const DataOut_DoFData<dim2, patch_dim, spacedim2, patch_spacedim> &source,
const Point<patch_spacedim> &shift = Point<patch_spacedim>());
- /**
- * @deprecated Use merge_patches() without the DoFHandlerType2 template
- * instead.
- */
- template <typename DoFHandlerType2>
- DEAL_II_DEPRECATED void
- merge_patches(const DataOut_DoFData<DoFHandlerType2::dimension,
- patch_dim,
- DoFHandlerType2::space_dimension,
- patch_spacedim> &source,
- const Point<patch_spacedim> &shift = Point<patch_spacedim>());
-
/**
* Release the pointers to the data vectors and the DoF handler. You have to
* set all data entries again using the add_data_vector() function. The
}
-
-template <int dim, int patch_dim, int spacedim, int patch_spacedim>
-template <typename DoFHandlerType2>
-void
-DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::merge_patches(
- const DataOut_DoFData<DoFHandlerType2::dimension,
- patch_dim,
- DoFHandlerType2::space_dimension,
- patch_spacedim> &source,
- const Point<patch_spacedim> & shift)
-{
- this->merge_patches<DoFHandlerType2::dimension,
- DoFHandlerType2::space_dimension>(source, shift);
-}
-
-
-
-namespace Legacy
-{
- /**
- * @deprecated Use dealii::DataOut_DoFData without the DoFHandlerType
- * template instead.
- */
- template <typename DoFHandlerType,
- int patch_dim,
- int patch_space_dim = patch_dim>
- using DataOut_DoFData DEAL_II_DEPRECATED =
- dealii::DataOut_DoFData<DoFHandlerType::dimension,
- patch_dim,
- DoFHandlerType::space_dimension,
- patch_space_dim>;
-} // namespace Legacy
-
-
DEAL_II_NAMESPACE_CLOSE
#endif
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/fe_collection.h>
#include <deal.II/hp/fe_values.h>
#include <deal.II/hp/q_collection.h>
DataOutBase::Patch<patch_dim, patch_spacedim> & patch);
};
-namespace Legacy
-{
- /**
- * @deprecated Use dealii::DataOutFaces without the DoFHandlerType template
- * instead.
- */
- template <int dim, typename DoFHandlerType = DoFHandler<dim>>
- using DataOutFaces DEAL_II_DEPRECATED =
- dealii::DataOutFaces<dim, DoFHandlerType::space_dimension>;
-} // namespace Legacy
-
DEAL_II_NAMESPACE_CLOSE
std::vector<DataOutBase::Patch<patch_dim, patch_spacedim>> &my_patches);
};
-namespace Legacy
-{
- /**
- * @deprecated Use dealii::DataOutRotation without the DoFHandlerType
- * template instead.
- */
- template <int dim, typename DoFHandlerType = DoFHandler<dim>>
- using DataOutRotation DEAL_II_DEPRECATED =
- dealii::DataOutRotation<dim, DoFHandlerType::space_dimension>;
-} // namespace Legacy
-
DEAL_II_NAMESPACE_CLOSE
class DoFHandler;
#endif
-/**
- * @deprecated Use DataOutStack<dim, spacedim> instead.
- */
-template <int dim, int spacedim = dim, typename DoFHandlerType = void>
-class DataOutStack;
-
-#ifndef DOXYGEN
-// prevent doxygen from complaining about potential recursive class relations
-template <int dim, int spacedim, typename DoFHandlerType>
-class DataOutStack : public DataOutStack<dim, spacedim, void>
-{
-public:
- DEAL_II_DEPRECATED
- DataOutStack()
- : DataOutStack<dim, spacedim, void>()
- {}
-};
-#endif // DOXYGEN
-
/**
* This class is used to stack the output from several computations into one
* output file by stacking the data sets in another coordinate direction
*
* @ingroup output
*/
-template <int dim, int spacedim>
-class DataOutStack<dim, spacedim, void>
- : public DataOutInterface<dim + 1, spacedim + 1>
+template <int dim, int spacedim = dim>
+class DataOutStack : public DataOutInterface<dim + 1, spacedim + 1>
{
static_assert(dim < 3,
"Because this class stacks data into the (dim+1)st "
* DoF handler to be used for the data corresponding to the present
* parameter value.
*/
- SmartPointer<const DoFHandler<dim, spacedim>,
- DataOutStack<dim, spacedim, void>>
+ SmartPointer<const DoFHandler<dim, spacedim>, DataOutStack<dim, spacedim>>
dof_handler;
/**
* data in the form of Patch structures (declared in the base class
* DataOutBase) to the actual output function.
*/
- virtual const std::vector<dealii::DataOutBase::Patch<
- DataOutStack<dim, spacedim, void>::patch_dim,
- DataOutStack<dim, spacedim, void>::patch_spacedim>> &
+ virtual const std::vector<
+ dealii::DataOutBase::Patch<DataOutStack<dim, spacedim>::patch_dim,
+ DataOutStack<dim, spacedim>::patch_spacedim>> &
get_patches() const override;
const typename DoFHandler<dim, spacedim>::cell_iterator &cell,
const unsigned int face_number);
- /**
- * Set the cell that is currently being used in evaluating the data
- * for which the DataPostprocessor object is being called.
- *
- * This function is not usually called from user space, but is instead
- * called by DataOut and similar classes when creating the object that
- * is then passed to DataPostprocessor.
- *
- * @deprecated Use the equivalent function with the dim template parameter
- * instead.
- */
- template <typename DoFHandlerType>
- DEAL_II_DEPRECATED void
- set_cell(const typename DoFHandlerType::cell_iterator &cell);
-
/**
* Query the cell on which we currently produce graphical output.
* See the documentation of the current class for an example on how
typename DoFHandler<dim, spacedim>::cell_iterator
get_cell() const;
- /**
- * Query the cell on which we currently produce graphical output.
- * See the documentation of the current class for an example on how
- * to use this function.
- *
- * @deprecated Use the equivalent function with the dim template parameter
- * instead.
- */
- template <typename DoFHandlerType>
- DEAL_II_DEPRECATED typename DoFHandlerType::cell_iterator
- get_cell() const;
-
/**
* Query the face number on which we currently produce graphical output.
* See the documentation of the current class for an example on how
namespace DataPostprocessorInputs
{
- template <int spacedim>
- template <typename DoFHandlerType>
- void
- CommonInputs<spacedim>::set_cell(
- const typename DoFHandlerType::cell_iterator &new_cell)
- {
- return set_cell<DoFHandlerType::dimension>(new_cell);
- }
-
-
-
template <int spacedim>
template <int dim>
void
- template <int spacedim>
- template <typename DoFHandlerType>
- typename DoFHandlerType::cell_iterator
- CommonInputs<spacedim>::get_cell() const
- {
- return get_cell<DoFHandlerType::dimension>();
- }
-
-
-
template <int spacedim>
template <int dim>
typename DoFHandler<dim, spacedim>::cell_iterator
};
} // namespace Functions
-namespace Legacy
-{
- namespace Functions
- {
- /**
- * @deprecated Use dealii::Functions::FEFieldFunction without the
- * DoFHandlerType template instead.
- */
- template <int dim,
- typename DoFHandlerType = DoFHandler<dim>,
- typename VectorType = Vector<double>>
- using FEFieldFunction DEAL_II_DEPRECATED = dealii::Functions::
- FEFieldFunction<dim, VectorType, DoFHandlerType::space_dimension>;
- } // namespace Functions
-} // namespace Legacy
-
DEAL_II_NAMESPACE_CLOSE
dof_values_on_cell;
};
-namespace Legacy
-{
- /**
- * @deprecated Use dealii::SolutionTransfer without the DoFHandlerType
- * template instead.
- */
- template <int dim,
- typename VectorType = Vector<double>,
- typename DoFHandlerType = DoFHandler<dim>>
- using SolutionTransfer DEAL_II_DEPRECATED =
- dealii::SolutionTransfer<dim, VectorType, DoFHandlerType::space_dimension>;
-} // namespace Legacy
-
DEAL_II_NAMESPACE_CLOSE
# include <deal.II/grid/tria_accessor.h>
# include <deal.II/grid/tria_iterator.h>
-# include <deal.II/hp/dof_handler.h>
-
# include <deal.II/lac/block_vector.h>
# include <deal.II/lac/la_parallel_block_vector.h>
# include <deal.II/lac/la_parallel_vector.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/grid/tria_iterator.templates.h>
-#include <deal.II/hp/dof_handler.h>
-
#include <vector>
DEAL_II_NAMESPACE_OPEN
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/grid/tria_iterator.templates.h>
-#include <deal.II/hp/dof_handler.h>
-
#include <deal.II/lac/block_vector.h>
#include <deal.II/lac/la_parallel_block_vector.h>
#include <deal.II/lac/la_parallel_vector.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/grid/tria_iterator.templates.h>
-#include <deal.II/hp/dof_handler.h>
-
#include <deal.II/lac/block_vector.h>
#include <deal.II/lac/la_parallel_block_vector.h>
#include <deal.II/lac/la_parallel_vector.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/fe_collection.h>
#include <deal.II/hp/fe_values.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/fe_collection.h>
#include <deal.II/hp/fe_values.h>
#include <deal.II/hp/mapping_collection.h>
template <int dim, int spacedim, typename VectorType>
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::InternalData(
+MappingFEField<dim, spacedim, VectorType>::InternalData::InternalData(
const FiniteElement<dim, spacedim> &fe,
const ComponentMask & mask)
: unit_tangentials()
template <int dim, int spacedim, typename VectorType>
std::size_t
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::
- memory_consumption() const
+MappingFEField<dim, spacedim, VectorType>::InternalData::memory_consumption()
+ const
{
Assert(false, ExcNotImplemented());
return 0;
template <int dim, int spacedim, typename VectorType>
double &
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::shape(
+MappingFEField<dim, spacedim, VectorType>::InternalData::shape(
const unsigned int qpoint,
const unsigned int shape_nr)
{
template <int dim, int spacedim, typename VectorType>
const Tensor<1, dim> &
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::derivative(
+MappingFEField<dim, spacedim, VectorType>::InternalData::derivative(
const unsigned int qpoint,
const unsigned int shape_nr) const
{
template <int dim, int spacedim, typename VectorType>
Tensor<1, dim> &
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::derivative(
+MappingFEField<dim, spacedim, VectorType>::InternalData::derivative(
const unsigned int qpoint,
const unsigned int shape_nr)
{
template <int dim, int spacedim, typename VectorType>
const Tensor<2, dim> &
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::
- second_derivative(const unsigned int qpoint,
- const unsigned int shape_nr) const
+MappingFEField<dim, spacedim, VectorType>::InternalData::second_derivative(
+ const unsigned int qpoint,
+ const unsigned int shape_nr) const
{
AssertIndexRange(qpoint * n_shape_functions + shape_nr,
shape_second_derivatives.size());
template <int dim, int spacedim, typename VectorType>
Tensor<2, dim> &
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::
- second_derivative(const unsigned int qpoint, const unsigned int shape_nr)
+MappingFEField<dim, spacedim, VectorType>::InternalData::second_derivative(
+ const unsigned int qpoint,
+ const unsigned int shape_nr)
{
AssertIndexRange(qpoint * n_shape_functions + shape_nr,
shape_second_derivatives.size());
template <int dim, int spacedim, typename VectorType>
const Tensor<3, dim> &
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::third_derivative(
+MappingFEField<dim, spacedim, VectorType>::InternalData::third_derivative(
const unsigned int qpoint,
const unsigned int shape_nr) const
{
template <int dim, int spacedim, typename VectorType>
Tensor<3, dim> &
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::third_derivative(
+MappingFEField<dim, spacedim, VectorType>::InternalData::third_derivative(
const unsigned int qpoint,
const unsigned int shape_nr)
{
template <int dim, int spacedim, typename VectorType>
const Tensor<4, dim> &
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::
- fourth_derivative(const unsigned int qpoint,
- const unsigned int shape_nr) const
+MappingFEField<dim, spacedim, VectorType>::InternalData::fourth_derivative(
+ const unsigned int qpoint,
+ const unsigned int shape_nr) const
{
AssertIndexRange(qpoint * n_shape_functions + shape_nr,
shape_fourth_derivatives.size());
template <int dim, int spacedim, typename VectorType>
Tensor<4, dim> &
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::
- fourth_derivative(const unsigned int qpoint, const unsigned int shape_nr)
+MappingFEField<dim, spacedim, VectorType>::InternalData::fourth_derivative(
+ const unsigned int qpoint,
+ const unsigned int shape_nr)
{
AssertIndexRange(qpoint * n_shape_functions + shape_nr,
shape_fourth_derivatives.size());
template <int dim, int spacedim, typename VectorType>
-MappingFEField<dim, spacedim, VectorType, void>::MappingFEField(
+MappingFEField<dim, spacedim, VectorType>::MappingFEField(
const DoFHandler<dim, spacedim> &euler_dof_handler,
const VectorType & euler_vector,
const ComponentMask & mask)
template <int dim, int spacedim, typename VectorType>
-MappingFEField<dim, spacedim, VectorType, void>::MappingFEField(
+MappingFEField<dim, spacedim, VectorType>::MappingFEField(
const DoFHandler<dim, spacedim> &euler_dof_handler,
const std::vector<VectorType> & euler_vector,
const ComponentMask & mask)
template <int dim, int spacedim, typename VectorType>
-MappingFEField<dim, spacedim, VectorType, void>::MappingFEField(
+MappingFEField<dim, spacedim, VectorType>::MappingFEField(
const DoFHandler<dim, spacedim> &euler_dof_handler,
const MGLevelObject<VectorType> &euler_vector,
const ComponentMask & mask)
template <int dim, int spacedim, typename VectorType>
-MappingFEField<dim, spacedim, VectorType, void>::MappingFEField(
- const MappingFEField<dim, spacedim, VectorType, void> &mapping)
+MappingFEField<dim, spacedim, VectorType>::MappingFEField(
+ const MappingFEField<dim, spacedim, VectorType> &mapping)
: reference_cell(mapping.reference_cell)
, uses_level_dofs(mapping.uses_level_dofs)
, euler_vector(mapping.euler_vector)
template <int dim, int spacedim, typename VectorType>
inline const double &
-MappingFEField<dim, spacedim, VectorType, void>::InternalData::shape(
+MappingFEField<dim, spacedim, VectorType>::InternalData::shape(
const unsigned int qpoint,
const unsigned int shape_nr) const
{
template <int dim, int spacedim, typename VectorType>
bool
-MappingFEField<dim, spacedim, VectorType, void>::preserves_vertex_locations()
- const
+MappingFEField<dim, spacedim, VectorType>::preserves_vertex_locations() const
{
return false;
}
template <int dim, int spacedim, typename VectorType>
bool
-MappingFEField<dim, spacedim, VectorType, void>::is_compatible_with(
+MappingFEField<dim, spacedim, VectorType>::is_compatible_with(
const ReferenceCell &reference_cell) const
{
Assert(dim == reference_cell.get_dimension(),
template <int dim, int spacedim, typename VectorType>
boost::container::small_vector<Point<spacedim>,
GeometryInfo<dim>::vertices_per_cell>
-MappingFEField<dim, spacedim, VectorType, void>::get_vertices(
+MappingFEField<dim, spacedim, VectorType>::get_vertices(
const typename Triangulation<dim, spacedim>::cell_iterator &cell) const
{
// we transform our tria iterator into a dof iterator so we can access
template <int dim, int spacedim, typename VectorType>
void
-MappingFEField<dim, spacedim, VectorType, void>::compute_shapes_virtual(
- const std::vector<Point<dim>> &unit_points,
- typename MappingFEField<dim, spacedim, VectorType, void>::InternalData &data)
- const
+MappingFEField<dim, spacedim, VectorType>::compute_shapes_virtual(
+ const std::vector<Point<dim>> & unit_points,
+ typename MappingFEField<dim, spacedim, VectorType>::InternalData &data) const
{
const auto fe = &euler_dof_handler->get_fe();
const unsigned int n_points = unit_points.size();
template <int dim, int spacedim, typename VectorType>
UpdateFlags
-MappingFEField<dim, spacedim, VectorType, void>::requires_update_flags(
+MappingFEField<dim, spacedim, VectorType>::requires_update_flags(
const UpdateFlags in) const
{
// add flags if the respective quantities are necessary to compute
template <int dim, int spacedim, typename VectorType>
void
-MappingFEField<dim, spacedim, VectorType, void>::compute_data(
+MappingFEField<dim, spacedim, VectorType>::compute_data(
const UpdateFlags update_flags,
const Quadrature<dim> &q,
const unsigned int n_original_q_points,
template <int dim, int spacedim, typename VectorType>
void
-MappingFEField<dim, spacedim, VectorType, void>::compute_face_data(
+MappingFEField<dim, spacedim, VectorType>::compute_face_data(
const UpdateFlags update_flags,
const Quadrature<dim> &q,
const unsigned int n_original_q_points,
template <int dim, int spacedim, typename VectorType>
typename std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
-MappingFEField<dim, spacedim, VectorType, void>::get_data(
+MappingFEField<dim, spacedim, VectorType>::get_data(
const UpdateFlags update_flags,
const Quadrature<dim> &quadrature) const
{
template <int dim, int spacedim, typename VectorType>
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
-MappingFEField<dim, spacedim, VectorType, void>::get_face_data(
+MappingFEField<dim, spacedim, VectorType>::get_face_data(
const UpdateFlags update_flags,
const hp::QCollection<dim - 1> &quadrature) const
{
template <int dim, int spacedim, typename VectorType>
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
-MappingFEField<dim, spacedim, VectorType, void>::get_subface_data(
+MappingFEField<dim, spacedim, VectorType>::get_subface_data(
const UpdateFlags update_flags,
const Quadrature<dim - 1> &quadrature) const
{
void
maybe_compute_q_points(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
- const typename dealii::MappingFEField<dim, spacedim, VectorType, void>::
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData & data,
const FiniteElement<dim, spacedim> &fe,
const ComponentMask & fe_mask,
void
maybe_update_Jacobians(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
- const typename dealii::MappingFEField<dim, spacedim, VectorType, void>::
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData & data,
const FiniteElement<dim, spacedim> &fe,
const ComponentMask & fe_mask,
void
maybe_update_jacobian_grads(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
- const typename dealii::MappingFEField<dim, spacedim, VectorType, void>::
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData & data,
const FiniteElement<dim, spacedim> & fe,
const ComponentMask & fe_mask,
void
maybe_update_jacobian_pushed_forward_grads(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
- const typename dealii::MappingFEField<dim, spacedim, VectorType, void>::
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData & data,
const FiniteElement<dim, spacedim> &fe,
const ComponentMask & fe_mask,
void
maybe_update_jacobian_2nd_derivatives(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
- const typename dealii::MappingFEField<dim, spacedim, VectorType, void>::
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData & data,
const FiniteElement<dim, spacedim> & fe,
const ComponentMask & fe_mask,
void
maybe_update_jacobian_pushed_forward_2nd_derivatives(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
- const typename dealii::MappingFEField<dim, spacedim, VectorType, void>::
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData & data,
const FiniteElement<dim, spacedim> &fe,
const ComponentMask & fe_mask,
void
maybe_update_jacobian_3rd_derivatives(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
- const typename dealii::MappingFEField<dim, spacedim, VectorType, void>::
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData & data,
const FiniteElement<dim, spacedim> & fe,
const ComponentMask & fe_mask,
void
maybe_update_jacobian_pushed_forward_3rd_derivatives(
const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
- const typename dealii::MappingFEField<dim, spacedim, VectorType, void>::
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData & data,
const FiniteElement<dim, spacedim> &fe,
const ComponentMask & fe_mask,
const unsigned int face_no,
const unsigned int subface_no,
const typename QProjector<dim>::DataSetDescriptor data_set,
- const typename dealii::MappingFEField<dim, spacedim, VectorType, void>::
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData &data,
internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
&output_data)
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, void>::
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData & data,
const FiniteElement<dim, spacedim> &fe,
const ComponentMask & fe_mask,
// need to recalculate data even when cells are similar.
template <int dim, int spacedim, typename VectorType>
CellSimilarity::Similarity
-MappingFEField<dim, spacedim, VectorType, void>::fill_fe_values(
+MappingFEField<dim, spacedim, VectorType>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const CellSimilarity::Similarity,
const Quadrature<dim> & quadrature,
template <int dim, int spacedim, typename VectorType>
void
-MappingFEField<dim, spacedim, VectorType, void>::fill_fe_face_values(
+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,
template <int dim, int spacedim, typename VectorType>
void
-MappingFEField<dim, spacedim, VectorType, void>::fill_fe_subface_values(
+MappingFEField<dim, spacedim, VectorType>::fill_fe_subface_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
const ArrayView<Tensor<rank, spacedim>> & output)
{
AssertDimension(input.size(), output.size());
- Assert(
- (dynamic_cast<
- const typename dealii::
- MappingFEField<dim, spacedim, VectorType, void>::InternalData *>(
- &mapping_data) != nullptr),
- ExcInternalError());
- const typename dealii::MappingFEField<dim, spacedim, VectorType, void>::
+ Assert((dynamic_cast<
+ const typename dealii::
+ MappingFEField<dim, spacedim, VectorType>::InternalData *>(
+ &mapping_data) != nullptr),
+ ExcInternalError());
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData &data = static_cast<
- const typename dealii::
- MappingFEField<dim, spacedim, VectorType, void>::InternalData &>(
- mapping_data);
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
+ InternalData &>(mapping_data);
switch (mapping_kind)
{
const ArrayView<Tensor<rank + 1, spacedim>> & output)
{
AssertDimension(input.size(), output.size());
- Assert(
- (dynamic_cast<
- const typename dealii::
- MappingFEField<dim, spacedim, VectorType, void>::InternalData *>(
- &mapping_data) != nullptr),
- ExcInternalError());
- const typename dealii::MappingFEField<dim, spacedim, VectorType, void>::
+ Assert((dynamic_cast<
+ const typename dealii::
+ MappingFEField<dim, spacedim, VectorType>::InternalData *>(
+ &mapping_data) != nullptr),
+ ExcInternalError());
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
InternalData &data = static_cast<
- const typename dealii::
- MappingFEField<dim, spacedim, VectorType, void>::InternalData &>(
- mapping_data);
+ const typename dealii::MappingFEField<dim, spacedim, VectorType>::
+ InternalData &>(mapping_data);
switch (mapping_kind)
{
template <int dim, int spacedim, typename VectorType>
void
-MappingFEField<dim, spacedim, VectorType, void>::transform(
+MappingFEField<dim, spacedim, VectorType>::transform(
const ArrayView<const Tensor<1, dim>> & input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
template <int dim, int spacedim, typename VectorType>
void
-MappingFEField<dim, spacedim, VectorType, void>::transform(
+MappingFEField<dim, spacedim, VectorType>::transform(
const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
template <int dim, int spacedim, typename VectorType>
void
-MappingFEField<dim, spacedim, VectorType, void>::transform(
+MappingFEField<dim, spacedim, VectorType>::transform(
const ArrayView<const Tensor<2, dim>> &input,
const MappingKind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
template <int dim, int spacedim, typename VectorType>
void
-MappingFEField<dim, spacedim, VectorType, void>::transform(
+MappingFEField<dim, spacedim, VectorType>::transform(
const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
template <int dim, int spacedim, typename VectorType>
void
-MappingFEField<dim, spacedim, VectorType, void>::transform(
+MappingFEField<dim, spacedim, VectorType>::transform(
const ArrayView<const Tensor<3, dim>> &input,
const MappingKind /*mapping_kind*/,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
template <int dim, int spacedim, typename VectorType>
Point<spacedim>
-MappingFEField<dim, spacedim, VectorType, void>::transform_unit_to_real_cell(
+MappingFEField<dim, spacedim, VectorType>::transform_unit_to_real_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const Point<dim> & p) const
{
template <int dim, int spacedim, typename VectorType>
Point<spacedim>
-MappingFEField<dim, spacedim, VectorType, void>::do_transform_unit_to_real_cell(
+MappingFEField<dim, spacedim, VectorType>::do_transform_unit_to_real_cell(
const InternalData &data) const
{
Point<spacedim> p_real;
template <int dim, int spacedim, typename VectorType>
Point<dim>
-MappingFEField<dim, spacedim, VectorType, void>::transform_real_to_unit_cell(
+MappingFEField<dim, spacedim, VectorType>::transform_real_to_unit_cell(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const Point<spacedim> & p) const
{
template <int dim, int spacedim, typename VectorType>
Point<dim>
-MappingFEField<dim, spacedim, VectorType, void>::do_transform_real_to_unit_cell(
+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,
template <int dim, int spacedim, typename VectorType>
unsigned int
-MappingFEField<dim, spacedim, VectorType, void>::get_degree() const
+MappingFEField<dim, spacedim, VectorType>::get_degree() const
{
return euler_dof_handler->get_fe().degree;
}
template <int dim, int spacedim, typename VectorType>
ComponentMask
-MappingFEField<dim, spacedim, VectorType, void>::get_component_mask() const
+MappingFEField<dim, spacedim, VectorType>::get_component_mask() const
{
return this->fe_mask;
}
template <int dim, int spacedim, typename VectorType>
std::unique_ptr<Mapping<dim, spacedim>>
-MappingFEField<dim, spacedim, VectorType, void>::clone() const
+MappingFEField<dim, spacedim, VectorType>::clone() const
{
- return std::make_unique<MappingFEField<dim, spacedim, VectorType, void>>(
- *this);
+ return std::make_unique<MappingFEField<dim, spacedim, VectorType>>(*this);
}
template <int dim, int spacedim, typename VectorType>
void
-MappingFEField<dim, spacedim, VectorType, void>::update_internal_dofs(
- const typename Triangulation<dim, spacedim>::cell_iterator &cell,
- const typename MappingFEField<dim, spacedim, VectorType, void>::InternalData
- &data) const
+MappingFEField<dim, spacedim, VectorType>::update_internal_dofs(
+ const typename Triangulation<dim, spacedim>::cell_iterator & cell,
+ const typename MappingFEField<dim, spacedim, VectorType>::InternalData &data)
+ const
{
Assert(euler_dof_handler != nullptr,
ExcMessage("euler_dof_handler is empty"));
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/mapping_collection.h>
#include <deal.II/lac/full_matrix.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/fe_values.h>
#include <deal.II/numerics/data_out.h>
template <int dim, int spacedim>
std::size_t
-DataOutStack<dim, spacedim, void>::DataVector::memory_consumption() const
+DataOutStack<dim, spacedim>::DataVector::memory_consumption() const
{
return (MemoryConsumption::memory_consumption(data) +
MemoryConsumption::memory_consumption(names));
template <int dim, int spacedim>
void
-DataOutStack<dim, spacedim, void>::new_parameter_value(const double p,
- const double dp)
+DataOutStack<dim, spacedim>::new_parameter_value(const double p,
+ const double dp)
{
parameter = p;
parameter_step = dp;
template <int dim, int spacedim>
void
-DataOutStack<dim, spacedim, void>::attach_dof_handler(
+DataOutStack<dim, spacedim>::attach_dof_handler(
const DoFHandler<dim, spacedim> &dof)
{
dof_handler = &dof;
template <int dim, int spacedim>
void
-DataOutStack<dim, spacedim, void>::declare_data_vector(
- const std::string &name,
- const VectorType vector_type)
+DataOutStack<dim, spacedim>::declare_data_vector(const std::string &name,
+ const VectorType vector_type)
{
std::vector<std::string> names;
names.push_back(name);
template <int dim, int spacedim>
void
-DataOutStack<dim, spacedim, void>::declare_data_vector(
+DataOutStack<dim, spacedim>::declare_data_vector(
const std::vector<std::string> &names,
const VectorType vector_type)
{
template <int dim, int spacedim>
template <typename number>
void
-DataOutStack<dim, spacedim, void>::add_data_vector(const Vector<number> &vec,
- const std::string & name)
+DataOutStack<dim, spacedim>::add_data_vector(const Vector<number> &vec,
+ const std::string & name)
{
const unsigned int n_components = dof_handler->get_fe(0).n_components();
template <int dim, int spacedim>
template <typename number>
void
-DataOutStack<dim, spacedim, void>::add_data_vector(
+DataOutStack<dim, spacedim>::add_data_vector(
const Vector<number> & vec,
const std::vector<std::string> &names)
{
template <int dim, int spacedim>
void
-DataOutStack<dim, spacedim, void>::build_patches(
- const unsigned int nnnn_subdivisions)
+DataOutStack<dim, spacedim>::build_patches(const unsigned int nnnn_subdivisions)
{
// this is mostly copied from the
// DataOut class
template <int dim, int spacedim>
void
-DataOutStack<dim, spacedim, void>::finish_parameter_value()
+DataOutStack<dim, spacedim>::finish_parameter_value()
{
// release lock on dof handler
dof_handler = nullptr;
template <int dim, int spacedim>
std::size_t
-DataOutStack<dim, spacedim, void>::memory_consumption() const
+DataOutStack<dim, spacedim>::memory_consumption() const
{
return (DataOutInterface<patch_dim, patch_spacedim>::memory_consumption() +
MemoryConsumption::memory_consumption(parameter) +
template <int dim, int spacedim>
const std::vector<
- dealii::DataOutBase::Patch<DataOutStack<dim, spacedim, void>::patch_dim,
- DataOutStack<dim, spacedim, void>::patch_spacedim>>
- &
- DataOutStack<dim, spacedim, void>::get_patches() const
+ dealii::DataOutBase::Patch<DataOutStack<dim, spacedim>::patch_dim,
+ DataOutStack<dim, spacedim>::patch_spacedim>> &
+DataOutStack<dim, spacedim>::get_patches() const
{
return patches;
}
template <int dim, int spacedim>
std::vector<std::string>
-DataOutStack<dim, spacedim, void>::get_dataset_names() const
+DataOutStack<dim, spacedim>::get_dataset_names() const
{
std::vector<std::string> names;
for (typename std::vector<DataVector>::const_iterator dataset =
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/hp/dof_handler.h>
-
#include <deal.II/lac/block_vector.h>
#include <deal.II/lac/la_parallel_block_vector.h>
#include <deal.II/lac/la_parallel_vector.h>
#include <deal.II/base/quadrature.h>
#include <deal.II/base/signaling_nan.h>
+#include <deal.II/dofs/dof_handler.h>
+
#include <deal.II/fe/fe_series.h>
#include <deal.II/grid/filtered_iterator.h>
-#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/q_collection.h>
#include <deal.II/lac/block_vector.h>
dof_handler, 1, 0, 0, periodicity_vectorDof);
}
- DoFTools::make_periodicity_constraints<DoFHandler<dim>>(periodicity_vectorDof,
- constraints);
+ DoFTools::make_periodicity_constraints<dim, dim>(periodicity_vectorDof,
+ constraints);
constraints.close();
std::map<types::global_dof_index, Point<dim>> support_points;
dof_handler, 1, 0, 0, periodicity_vectorDof);
}
- DoFTools::make_periodicity_constraints<DoFHandler<dim>>(periodicity_vectorDof,
- constraints);
+ DoFTools::make_periodicity_constraints<dim, dim>(periodicity_vectorDof,
+ constraints);
constraints.close();
std::map<types::global_dof_index, Point<dim>> support_points;
// get the cell this all belongs to
typename DoFHandler<dim>::cell_iterator cell =
- input_data.template get_cell<DoFHandler<dim>>();
+ input_data.template get_cell<dim>();
Assert(input_data.solution_values[q] ==
double(cell->active_cell_index()),
// get the cell this all belongs to
typename DoFHandler<dim>::cell_iterator cell =
- input_data.template get_cell<DoFHandler<dim>>();
+ input_data.template get_cell<dim>();
Assert(input_data.solution_values[q](0) ==
double(cell->active_cell_index()),
// get the cell this all belongs to
typename DoFHandler<dim>::cell_iterator cell =
- input_data.template get_cell<DoFHandler<dim>>();
+ input_data.template get_cell<dim>();
Assert(input_data.solution_values[q] ==
double(cell->active_cell_index()),
// get the cell this all belongs to
typename DoFHandler<dim>::cell_iterator cell =
- input_data.template get_cell<DoFHandler<dim>>();
+ input_data.template get_cell<dim>();
Assert(input_data.solution_values[q](0) ==
double(cell->active_cell_index()),
// get the cell this all belongs to
typename DoFHandler<dim>::cell_iterator cell =
- input_data.template get_cell<DoFHandler<dim>>();
+ input_data.template get_cell<dim>();
Assert(input_data.solution_values[q] ==
double(cell->active_cell_index()),
cell != dof_handler.end();
++cell)
deallog << cell << ": "
- << DoFTools::count_dofs_on_patch<DoFHandler<dim>>(
+ << DoFTools::count_dofs_on_patch<dim, dim>(
GridTools::get_patch_around_cell<DoFHandler<dim>>(cell))
<< std::endl;
}
// try all possible block
// masks, which we encode as bit
// strings
- for (unsigned int int_mask = 0; int_mask < (1U << element[0].n_blocks());
+ for (unsigned int int_mask = 0; int_mask < (1U << element.n_blocks());
++int_mask)
{
- std::vector<bool> component_mask(element[0].n_blocks());
- for (unsigned int c = 0; c < element[0].n_blocks(); ++c)
+ std::vector<bool> component_mask(element.n_blocks());
+ for (unsigned int c = 0; c < element.n_blocks(); ++c)
component_mask[c] = (int_mask & (1 << c));
for (unsigned int level = 0; level < tr.n_levels(); ++level)
++cell)
{
const std::vector<types::global_dof_index> m =
- DoFTools::get_dofs_on_patch<DoFHandler<dim>>(
+ DoFTools::get_dofs_on_patch<dim, dim>(
GridTools::get_patch_around_cell<DoFHandler<dim>>(cell));
deallog << cell << ": ";
for (unsigned int i = 0; i < m.size(); ++i)
#include <deal.II/base/function.h>
-#include <deal.II/hp/dof_handler.h>
+#include <deal.II/dofs/dof_handler.h>
+
#include <deal.II/hp/fe_values.h>
#include "../tests.h"
quadrature_collection_mf.push_back(QGauss<1>(deg + 1));
}
- hp::DoFHandler<dim> dof(tria);
+ DoFHandler<dim> dof(tria);
// set the active FE index in a random order
{
- typename hp::DoFHandler<dim>::active_cell_iterator cell =
- dof.begin_active(),
- endc = dof.end();
- for (; cell != endc; ++cell)
+ for (const auto &cell : dof.active_cell_iterators())
{
const unsigned int fe_index = Testing::rand() % max_degree;
cell->set_active_fe_index(fe_index + 1);
// We cannot set random cells to FE_Nothing. We get the following error
// The violated condition was: dominating_fe.n_dofs_per_face(face) <=
// subface_fe.n_dofs_per_face(face)
- cell = dof.begin_active();
- cell->set_active_fe_index(0);
+ dof.begin_active()->set_active_fe_index(0);
}
// setup DoFs
FullMatrix<double> cell_matrix;
std::vector<types::global_dof_index> local_dof_indices;
- typename hp::DoFHandler<dim>::active_cell_iterator cell =
- dof.begin_active(),
- endc = dof.end();
- for (; cell != endc; ++cell)
+ for (const auto &cell : dof.active_cell_iterators())
{
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
GridTools::collect_periodic_faces(
dof_handler, 2, 3, 1, periodicity_vector, Tensor<1, dim>(), matrix);
- DoFTools::make_periodicity_constraints<DoFHandler<dim>>(
- periodicity_vector,
- constraints,
- fe.component_mask(velocities),
- first_vector_components);
+ DoFTools::make_periodicity_constraints<dim, dim>(periodicity_vector,
+ constraints,
+ fe.component_mask(
+ velocities),
+ first_vector_components);
#endif
}
GridTools::collect_periodic_faces(
dof_handler, 4, 0, 1, periodicity_vector, offset, rot_matrix);
- DoFTools::make_periodicity_constraints<DoFHandler<dim>>(
- periodicity_vector,
- constraints,
- fe.component_mask(velocities),
- first_vector_components);
+ DoFTools::make_periodicity_constraints<dim, dim>(periodicity_vector,
+ constraints,
+ fe.component_mask(
+ velocities),
+ first_vector_components);
VectorTools::interpolate_boundary_values(dof_handler,
1,
GridTools::collect_periodic_faces(
dof_handler, 42, 43, dim - 1, periodicity_vector);
- DoFTools::make_periodicity_constraints<DoFHandler<dim>>(periodicity_vector,
- constraints);
+ DoFTools::make_periodicity_constraints<dim, dim>(periodicity_vector,
+ constraints);
}
constraints.close();
/*direction*/ d,
periodicity_vectorDof);
- DoFTools::make_periodicity_constraints<DoFHandler<dim>>(periodicity_vectorDof,
- constraints);
+ DoFTools::make_periodicity_constraints<dim, dim>(periodicity_vectorDof,
+ constraints);
constraints.close();
const std::vector<IndexSet> &locally_owned_dofs =
/*direction*/ d,
periodicity_vectorDof);
- DoFTools::make_periodicity_constraints<DoFHandler<dim>>(periodicity_vectorDof,
- constraints);
+ DoFTools::make_periodicity_constraints<dim, dim>(periodicity_vectorDof,
+ constraints);
const bool consistent =
constraints.is_consistent_in_parallel(locally_owned_dofs,
projects / dealii.git / commitdiff