- TrilinosWrappers::*Vector*::compress with an Epetra_CombineMode
argument
<br>
- (Wolfgang Bangerth, 2014/12/29-2015/01/09)
+ This release also removes the deprecated class MGDoFHandler. The
+ functionality of this class had previously been incorporated into
+ the DoFHandler class. Unlike the changes above, if you were still
+ using this class, you will need to do the following changes to
+ your code:
+ - Where you called <code>mg_dof_handler.distribute_dofs()</code>
+ you now also need to explicitly call
+ <code>mg_dof_handler.distribute_mg_dofs()</code>.
+ - If you called <code>mg_dof_handler.begin(level)</code>, you
+ will now have to write this as
+ <code>mg_dof_handler.begin_mg(level)</code> to make clear that
+ you are not just interested in an iterator to a cell on a given
+ level, but in fact to a cell that can access the degrees of
+ freedom on a particular level of a multigrid hierarchy.
+ - The type previously referred to as
+ <code>MGDoFHandler::cell_iterator</code> now corresponds to
+ <code>MGDoFHandler::level_cell_iterator</code>.
+ - Where you previously called DoFRenumbering::component_wise
+ for the entire MGDoFHandler object, you now need to call
+ this function for the DoFHandler object, and then call the
+ same function with the <code>level</code> argument for each
+ of the levels of the triangulation individually.
+ <br>
+ (Wolfgang Bangerth, 2014/12/29-2015/01/11)
</li>
<li> Removed: The config.h file no longer exports HAVE_* definitions.
// The rest of the include files deals with
// the mechanics of multigrid as a linear
// operator (solver or preconditioner).
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_constrained_dofs.h>
#include <deal.II/multigrid/multigrid.h>
#include <deal.II/multigrid/mg_transfer.h>
* multigrid. The active DoFs need to be distributed using distribute_dofs()
* before calling this function and the @p fe needs to be identical to the
* finite element passed to distribute_dofs().
- *
- * This replaces the functionality of the old MGDoFHandler.
*/
virtual void distribute_mg_dofs (const FiniteElement<dim, spacedim> &fe);
*
* At the end of distribute_dofs(), the number of degrees of freedom in each
* block is counted, and stored in a BlockInfo object, which can be accessed
- * here. In an MGDoFHandler, the same is done on each level. Additionally,
+ * here. If you have previously called distribute_mg_dofs(),
+ * the same is done on each level of the multigrid hierarchy. Additionally,
* the block structure on each cell can be generated in this object by
* calling initialize_local_block_info().
*/
const unsigned int version);
/**
- * Make the DoFHandler and MGDoFHandler classes a friend, so that they
- * can resize arrays as necessary.
+ * Declare the classes that store levels and faces of DoFs
+ * friends so that they can resize arrays.
*/
template <int> friend class DoFLevel;
template <int> friend class DoFFaces;
#include <deal.II/base/point.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <vector>
*
* For finite elements with only one component, or a single non-primitive
* base element, this function is the identity operation.
- *
- * @note A similar function, which renumbered all levels existed for
- * MGDoFHandler. This function was deleted. Thus, you have to call the level
- * function for each level now.
*/
template <int dim, int spacedim>
void
/**
* Sort the degrees of freedom by component. It does the same thing as the
* above function, only that it does this for one single level of a multi-
- * level discretization. The non-multigrid part of the MGDoFHandler is not
+ * level discretization. The non-multigrid part of the the DoFHandler is not
* touched.
*/
template <class DH>
const unsigned int level,
const std::vector<unsigned int> &target_component = std::vector<unsigned int>());
-
- /**
- * Sort the degrees of freedom by component. It does the same thing as the
- * previous functions, but more: it renumbers not only every level of the
- * multigrid part, but also the global, i.e. non-multigrid components.
- */
- template <int dim>
- void
- component_wise (MGDoFHandler<dim> &dof_handler,
- const std::vector<unsigned int> &target_component = std::vector<unsigned int>());
-
/**
* Computes the renumbering vector needed by the component_wise() functions.
* Does not perform the renumbering on the DoFHandler dofs but returns the
void
block_wise (hp::DoFHandler<dim> &dof_handler);
- /**
- * Sort the degrees of freedom by block. It does the same thing as the above
- * function, only that it does this for one single level of a multi-level
- * discretization. The non-multigrid part of the MGDoFHandler is not
- * touched.
- */
- template <int dim>
- void
- block_wise (MGDoFHandler<dim> &dof_handler,
- const unsigned int level);
-
-
- /**
- * Sort the degrees of freedom by block. It does the same thing as the
- * previous functions, but more: it renumbers not only every level of the
- * multigrid part, but also the global, i.e. non-multigrid components.
- */
- template <int dim>
- void
- block_wise (MGDoFHandler<dim> &dof_handler);
-
/**
* Computes the renumbering vector needed by the block_wise() functions.
* Does not perform the renumbering on the DoFHandler dofs but returns the
const std::vector<bool> &selected_dofs);
/**
- * Computes the renumbering vector on each level needed by the
+ * This function computes the renumbering vector on each level needed by the
* sort_selected_dofs_back() function. Does not perform the renumbering on
- * the MGDoFHandler dofs but returns the renumbering vector.
+ * the DoFHandler dofs but only computes the renumbering and returns
+ * the renumbering vector.
*
* @pre The @p selected_dofs array must have as many elements as the @p
* dof_handler has degrees of freedom on the given level.
template <int dim, int spacedim> class DoFHandler;
template <int dim, int spacedim> class MappingCollection;
}
-template <int dim, int spacedim> class MGDoFHandler;
class ConstraintMatrix;
template <class GridClass> class InterGridMap;
template <int dim, int spacedim> class Mapping;
#include <deal.II/fe/fe_update_flags.h>
#include <deal.II/fe/fe_values_extractors.h>
#include <deal.II/fe/mapping.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <algorithm>
#include <memory>
/**
* Given two mesh containers (i.e. objects of type Triangulation,
- * DoFHandler, hp::DoFHandler, or MGDoFHandler) that are based on the same
+ * DoFHandler, or hp::DoFHandler) that are based on the same
* coarse mesh, this function figures out a set of cells that are matched
* between the two meshes and where at most one of the meshes is more
* refined on this cell. In other words, it finds the smallest cells that
/**
* The same function as above, but working on arguments of type DoFHandler,
- * hp::DoFHandler, or MGDoFHandler. This function is provided to allow
+ * or hp::DoFHandler. This function is provided to allow
* calling have_same_coarse_mesh for all types of containers representing
* triangulations or the classes built on triangulations.
*
*
* The implementation of this class is such that not only cell iterators into
* triangulations can be mapped, but also iterators into objects of type
- * DoFHandler, hp::DoFHandler and MGDoFHandler. The extension to other classes
+ * DoFHandler or hp::DoFHandler. The extension to other classes
* offering iterator functions and some minor additional requirements is
* simple.
*
* Note that this class could in principle be based on the C++
- * <tt>map<Key,Value></tt> data type. Instead, it uses another data format
+ * <tt>std::map<Key,Value></tt> data type. Instead, it uses another data format
* which is more effective both in terms of computing time for access as well
* as with regard to memory consumpion.
*
*
* Note that the template parameters to this class have to be given as
* <tt>InterGridMap<DoFHandler<2> ></tt>, which here is DoFHandler (and could
- * equally well be Triangulation, PersistentTriangulation, hp::DoFHandler or
- * MGDoFHandler).
+ * equally well be Triangulation, PersistentTriangulation, or hp::DoFHandler).
*
* @ingroup grid
* @author Wolfgang Bangerth, 1999
{
template <int dim, int spacedim> class DoFHandler;
}
-template <int dim, int spacedim> class MGDoFHandler;
/*------------------------------------------------------------------------*/
* but you may write your own version (non-virtual, since we use templates) to
* add functionality.
*
- * The accessors provided by the library are distributed in three groups,
- * determined by whether they access the data of Triangulation, DoFHandler or
- * MGDoFHandler. They are derived from TriaAccessor, DoFAccessor and
- * MGDoFAccessor, respectively. In each group, there is an accessor to cells,
- * which have more functionality.
+ * The accessors provided by the library consists of two groups,
+ * determined by whether they access the data of Triangulation objects or
+ * DoFHandler/hp::DoFHandler objects. They are derived from TriaAccessor and
+ * DoFAccessor, respectively. Each group also has specialized accessors for
+ * cells (as opposed to faces and lines) that offer more functionality such as
+ * accessing neighbors.
*
* @attention It seems impossible to preserve constness of a triangulation
* through iterator usage. Thus, if you declare pointers to a <tt>const</tt>
#include <deal.II/lac/block_vector_base.h>
#include <deal.II/lac/constraint_matrix.h>
#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/q_collection.h>
#include <deal.II/matrix_free/helper_functions.h>
-namespace internal
-{
- namespace MatrixFree
- {
- // resolve DoFHandler types
-
- // MGDoFHandler is deprecated in deal.II but might still be present in
- // user code, so we need to resolve its type (fortunately, it is derived
- // from DoFHandler, so we can static_cast it to a DoFHandler<dim>)
- template <typename DH>
- inline
- std::vector<const dealii::DoFHandler<DH::dimension> *>
- resolve_dof_handler (const std::vector<const DH *> &dof_handler)
- {
- std::vector<const dealii::DoFHandler<DH::dimension> *> conversion(dof_handler.size());
- for (unsigned int i=0; i<dof_handler.size(); ++i)
- conversion[i] = static_cast<const dealii::DoFHandler<DH::dimension> *>(dof_handler[i]);
- return conversion;
- }
-
- template <int dim>
- inline
- std::vector<const dealii::hp::DoFHandler<dim> *>
- resolve_dof_handler (const std::vector<const dealii::hp::DoFHandler<dim> *> &dof_handler)
- {
- return dof_handler;
- }
- }
-}
-
-
-
template <int dim, typename Number>
template <typename DH, typename Quad>
void MatrixFree<dim,Number>::
for (unsigned int q=0; q<quad.size(); ++q)
quad_hp.push_back (hp::QCollection<1>(quad[q]));
internal_reinit (mapping,
- internal::MatrixFree::resolve_dof_handler(dof_handler),
+ dof_handler,
constraint, locally_owned_set, quad_hp, additional_data);
}
constraint_values,
cell_at_boundary);
}
- // ok, now we are requested to use a level in a MGDoFHandler
+ // ok, now we are requested to use a level in a MG DoFHandler
else if (dof_handlers.active_dof_handler == DoFHandlers::usual &&
dof_handlers.level != numbers::invalid_unsigned_int)
{
class BlockIndices;
template<int,int> class DoFHandler;
-template<int,int> class MGDoFHandler;
+
/**
* A collection of functions and classes for the mesh loops that are an
+++ /dev/null
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 1998 - 2013 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 at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-#ifndef __deal2__mg_dof_handler_h
-#define __deal2__mg_dof_handler_h
-
-//TODO: MgDoFHandler should be marked deprecated, but is used everywhere...
-//#warning MGDoFHandler is deprecated
-
-#include <deal.II/base/config.h>
-#include <deal.II/dofs/dof_handler.h>
-//#include <deal.II/multigrid/mg_dof_iterator_selector.h>
-
-DEAL_II_NAMESPACE_OPEN
-
-
-namespace internal
-{
- namespace MGDoFHandler
- {
- struct Implementation;
- }
-}
-
-
-/*!@addtogroup mg */
-/*@{*/
-
-
-/**
- * @deprecated All functionality of this class has been moved to DoFHandler.
- * Thus, this class is only a wrapper left in the library for compatibility
- * reasons.
- *
- * This class manages degrees of freedom for a multilevel hierarchy of grids.
- * It does mostly the same as does the @p DoDHandler class, but it uses a
- * separate enumeration of the degrees of freedom on each level. For example,
- * a vertex has several DoF numbers, one for each level of the triangulation
- * on which it exists.
- *
- * @todo This class has not yet been implemented for the use in the
- * codimension one case (<tt>spacedim != dim </tt>).
- *
- * @ingroup dofs
- * @author Wolfgang Bangerth, 1998, 1999 Markus Bürg, Timo Heister, Guido
- * Kanschat, 2012
- */
-template <int dim, int spacedim=dim>
-class MGDoFHandler : public DoFHandler<dim,spacedim>
-{
- typedef dealii::internal::DoFHandler::Iterators<DoFHandler<dim,spacedim>, true> IteratorSelector;
-public:
- typedef typename IteratorSelector::CellAccessor cell_accessor;
- typedef typename IteratorSelector::FaceAccessor face_accessor;
-
- typedef typename IteratorSelector::raw_line_iterator raw_line_iterator;
- typedef typename IteratorSelector::line_iterator line_iterator;
- typedef typename IteratorSelector::active_line_iterator active_line_iterator;
-
- typedef typename IteratorSelector::quad_iterator quad_iterator;
- typedef typename IteratorSelector::active_quad_iterator active_quad_iterator;
-
- typedef typename IteratorSelector::hex_iterator hex_iterator;
- typedef typename IteratorSelector::active_hex_iterator active_hex_iterator;
-
- typedef typename IteratorSelector::cell_iterator cell_iterator;
- typedef typename IteratorSelector::active_cell_iterator active_cell_iterator;
-
- typedef typename IteratorSelector::face_iterator face_iterator;
- typedef typename IteratorSelector::active_face_iterator active_face_iterator;
-
- /**
- * Make the dimension and the space_dimension available in function
- * templates.
- */
- static const unsigned int dimension = dim;
-
- static const unsigned int space_dimension = spacedim;
-
- /**
- * Default constructor, which will require a call to initialize() later to
- * set the Triangulation.
- */
- MGDoFHandler ();
-
- /**
- * Constructor. Take @p tria as the triangulation to work on.
- */
- MGDoFHandler (const Triangulation<dim, spacedim> &tria);
-
- /**
- * Destructor
- */
- virtual ~MGDoFHandler ();
-
- /**
- * Go through the triangulation and distribute the degrees of freedoms
- * needed for the given finite element according to the given distribution
- * method. We first call the DoFHandler's function and then distribute the
- * levelwise numbers.
- *
- * A copy of the transferred finite element is stored.
- */
- virtual void distribute_dofs (const FiniteElement<dim,spacedim> &);
-
- /**
- * @name Cell iterator functions
- */
- /*@{*/
- /**
- * Iterator to the first used cell on level @p level.
- */
- cell_iterator begin (const unsigned int level = 0) const;
-
- /**
- * Iterator past the end; this iterator serves for comparisons of iterators
- * with past-the-end or before-the-beginning states.
- */
- cell_iterator end () const;
-
- /**
- * Return an iterator which is the first iterator not on level. If @p level
- * is the last level, then this returns <tt>end()</tt>.
- */
- cell_iterator end (const unsigned int level) const;
-
- //@}
-
-} DEAL_II_DEPRECATED;
-
-/*@}*/
-
-
-DEAL_II_NAMESPACE_CLOSE
-
-
-#endif
+++ /dev/null
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 1998 - 2013 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 at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-#ifndef __deal2__mg_dof_iterator_selector_h
-#define __deal2__mg_dof_iterator_selector_h
-
-
-#include <deal.II/base/config.h>
-
-
-DEAL_II_NAMESPACE_OPEN
-
-template <int structdim, int dim, int spacedim> class MGDoFAccessor;
-template <int dim, int spacedim> class MGDoFCellAccessor;
-template <int, int, int> class InvalidAccessor;
-
-template <typename Accessor> class TriaRawIterator;
-template <typename Accessor> class TriaIterator;
-template <typename Accessor> class TriaActiveIterator;
-
-
-namespace internal
-{
- namespace MGDoFHandler
- {
- template <int dim, int spacedim>
- class Iterators;
-
-
- /**
- * Iterators for MGDofHandler in one dimension. See the
- * @ref Iterators
- * module for more information.
- */
- template <int spacedim>
- class Iterators<1,spacedim>
- {
- public:
- typedef dealii::MGDoFCellAccessor<1,spacedim> CellAccessor;
- typedef dealii::MGDoFAccessor<0,1,spacedim> FaceAccessor;
-
- typedef TriaRawIterator <CellAccessor> raw_line_iterator;
- typedef TriaIterator <CellAccessor> line_iterator;
- typedef TriaActiveIterator<CellAccessor> active_line_iterator;
-
- typedef TriaRawIterator <InvalidAccessor<2,1,spacedim> > raw_quad_iterator;
- typedef TriaIterator <InvalidAccessor<2,1,spacedim> > quad_iterator;
- typedef TriaActiveIterator<InvalidAccessor<2,1,spacedim> > active_quad_iterator;
-
- typedef TriaRawIterator <InvalidAccessor<3,1,spacedim> > raw_hex_iterator;
- typedef TriaIterator <InvalidAccessor<3,1,spacedim> > hex_iterator;
- typedef TriaActiveIterator<InvalidAccessor<3,1,spacedim> > active_hex_iterator;
-
- typedef raw_line_iterator raw_cell_iterator;
- typedef line_iterator cell_iterator;
- typedef active_line_iterator active_cell_iterator;
-
- typedef TriaRawIterator <FaceAccessor> raw_face_iterator;
- typedef TriaIterator <FaceAccessor> face_iterator;
- typedef TriaActiveIterator<FaceAccessor> active_face_iterator;
- };
-
-
-
- /**
- * Iterators for MGDofHandler in two dimensions. See the
- * @ref Iterators
- * module for more information.
- */
- template <int spacedim>
- class Iterators<2,spacedim>
- {
- public:
- typedef dealii::MGDoFCellAccessor<2,spacedim> CellAccessor;
- typedef dealii::MGDoFAccessor<1,2,spacedim> FaceAccessor;
-
- typedef TriaRawIterator <FaceAccessor> raw_line_iterator;
- typedef TriaIterator <FaceAccessor> line_iterator;
- typedef TriaActiveIterator<FaceAccessor> active_line_iterator;
-
- typedef TriaRawIterator <CellAccessor> raw_quad_iterator;
- typedef TriaIterator <CellAccessor> quad_iterator;
- typedef TriaActiveIterator<CellAccessor> active_quad_iterator;
-
- typedef TriaRawIterator <InvalidAccessor<3,2,spacedim> > raw_hex_iterator;
- typedef TriaIterator <InvalidAccessor<3,2,spacedim> > hex_iterator;
- typedef TriaActiveIterator<InvalidAccessor<3,2,spacedim> > active_hex_iterator;
-
- typedef raw_quad_iterator raw_cell_iterator;
- typedef quad_iterator cell_iterator;
- typedef active_quad_iterator active_cell_iterator;
-
- typedef raw_line_iterator raw_face_iterator;
- typedef line_iterator face_iterator;
- typedef active_line_iterator active_face_iterator;
- };
-
-
-
- /**
- * Iterators for MGDofHandler in three dimensions. See the
- * @ref Iterators
- * module for more information.
- */
- template <int spacedim>
- class Iterators<3,spacedim>
- {
- public:
- typedef dealii::MGDoFCellAccessor<3,spacedim> CellAccessor;
- typedef dealii::MGDoFAccessor<2,3,spacedim> FaceAccessor;
-
- typedef TriaRawIterator <dealii::MGDoFAccessor<1,3,spacedim> > raw_line_iterator;
- typedef TriaIterator <dealii::MGDoFAccessor<1,3,spacedim> > line_iterator;
- typedef TriaActiveIterator<dealii::MGDoFAccessor<1,3,spacedim> > active_line_iterator;
-
- typedef TriaRawIterator <FaceAccessor> raw_quad_iterator;
- typedef TriaIterator <FaceAccessor> quad_iterator;
- typedef TriaActiveIterator<FaceAccessor> active_quad_iterator;
-
- typedef TriaRawIterator <CellAccessor> raw_hex_iterator;
- typedef TriaIterator <CellAccessor> hex_iterator;
- typedef TriaActiveIterator<CellAccessor> active_hex_iterator;
-
- typedef raw_hex_iterator raw_cell_iterator;
- typedef hex_iterator cell_iterator;
- typedef active_hex_iterator active_cell_iterator;
-
- typedef raw_quad_iterator raw_face_iterator;
- typedef quad_iterator face_iterator;
- typedef active_quad_iterator active_face_iterator;
- };
- }
-}
-
-
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-/*---------------------------- mg_dof_iterator_selector.h ---------------------------*/
#include <deal.II/lac/vector.h>
#include <deal.II/multigrid/mg_base.h>
#include <deal.II/base/mg_level_object.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <vector>
template <int dim, int spacedim> class Mapping;
template <int dim, int spacedim> class DoFHandler;
-template <int dim, int spacedim> class MGDoFHandler;
template <int dim, int spacedim> class FEValues;
namespace hp
#include <deal.II/dofs/block_info.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_tools.h>
#include <deal.II/fe/fe.h>
#include <deal.II/fe/fe_tools.h>
// component_wise(dof_handler, level, component_order_arg);
}
- // This function is only for compatibility reasons and will vanish in 8.0
- template <int dim>
- void
- component_wise (MGDoFHandler<dim> &dof_handler,
- const std::vector<unsigned int> &component_order_arg)
- {
- DoFHandler<dim> &active_dof = dof_handler;
- component_wise(active_dof, component_order_arg);
- for (unsigned int level=0; level<dof_handler.get_tria().n_levels(); ++level)
- component_wise(dof_handler, level, component_order_arg);
- }
template <int dim>
- template <int dim>
- void
- block_wise (MGDoFHandler<dim> &dof_handler)
- {
- // renumber the non-MG part of
- // the DoFHandler in parallel to
- // the MG part. Because
- // MGDoFHandler::renumber_dofs
- // uses the user flags we can't
- // run renumbering on individual
- // levels in parallel to the
- // other levels
- void (*non_mg_part) (DoFHandler<dim> &)
- = &block_wise<dim>;
- Threads::Task<>
- task = Threads::new_task (non_mg_part, dof_handler);
-
- for (unsigned int level=0; level<dof_handler.get_tria().n_levels(); ++level)
- block_wise (dof_handler, level);
-
- task.join();
- }
-
-
-
template <int dim, int spacedim, class ITERATOR, class ENDITERATOR>
types::global_dof_index
compute_block_wise (std::vector<types::global_dof_index> &new_indices,
unsigned int,
const std::vector<unsigned int>&);
- template
- void component_wise
- (MGDoFHandler<deal_II_dimension>&,
- const std::vector<unsigned int>&);
-
- template
- void component_wise
- (MGDoFHandler<deal_II_dimension>&,
- unsigned int,
- const std::vector<unsigned int>&);
-
template
void block_wise<deal_II_dimension>
(hp::DoFHandler<deal_II_dimension>&);
const hp::DoFHandler<deal_II_dimension>&,
const std::vector<hp::DoFHandler<deal_II_dimension>::active_cell_iterator>&);
- template void
- downstream<MGDoFHandler<deal_II_dimension> >
- (MGDoFHandler<deal_II_dimension>&,
- unsigned int,
- const Point<deal_II_dimension>&,
- const bool);
-
template void
compute_downstream<hp::DoFHandler<deal_II_dimension> >
(std::vector<types::global_dof_index>&,std::vector<types::global_dof_index>&,
(DoFHandler<deal_II_dimension> &,
const std::vector<bool> &);
- template
- void sort_selected_dofs_back<MGDoFHandler<deal_II_dimension> >
- (MGDoFHandler<deal_II_dimension> &,
- const std::vector<bool> &,
- const unsigned int);
-
template
void
compute_sort_selected_dofs_back<DoFHandler<deal_II_dimension> >
const DoFHandler<deal_II_dimension> &,
const std::vector<bool> &);
- template
- void
- compute_sort_selected_dofs_back<MGDoFHandler<deal_II_dimension> >
- (std::vector<types::global_dof_index>&,
- const MGDoFHandler<deal_II_dimension> &,
- const std::vector<bool> &,
- const unsigned int);
-
template
void random<hp::DoFHandler<deal_II_dimension> >
(hp::DoFHandler<deal_II_dimension> &);
const unsigned int,
const bool,
const std::vector<types::global_dof_index>&);
-
- template
- void Cuthill_McKee<MGDoFHandler<deal_II_dimension> >
- (MGDoFHandler<deal_II_dimension>&,
- const unsigned int,
- const bool,
- const std::vector<types::global_dof_index>&);
-
\} // namespace DoFRenumbering
#endif
}
#include <deal.II/hp/fe_values.h>
#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <algorithm>
#include <numeric>
template void
DoFTools::make_cell_patches<DoFHandler<deal_II_dimension>,SP>
(SP&, const DoFHandler<deal_II_dimension>&, const unsigned int, const std::vector<bool>&, types::global_dof_index);
-
- template void
- DoFTools::make_cell_patches<MGDoFHandler<deal_II_dimension>,SP>
- (SP&, const MGDoFHandler<deal_II_dimension>&, const unsigned int, const std::vector<bool>&, types::global_dof_index);
-}
+ }
void DoFTools::make_child_patches(SparsityPattern&, const DoFHandler<deal_II_dimension>&,
unsigned int, bool, bool);
- template
- void DoFTools::make_vertex_patches (SparsityPattern&, const MGDoFHandler<deal_II_dimension>&,
- unsigned int, bool, bool, bool, bool);
-
- template
- void DoFTools::make_single_patch (SparsityPattern&, const MGDoFHandler<deal_II_dimension>&,
- unsigned int, bool);
-
- template
- void DoFTools::make_child_patches(SparsityPattern&, const MGDoFHandler<deal_II_dimension>&,
- unsigned int, bool, bool);
-
-
// TODO: can cleanup a bit more to fit into the scheme used above
template
std::vector<bool>&);
#endif
-template void DoFTools::extract_level_dofs<MGDoFHandler<deal_II_dimension> >
-(const unsigned int level,
- const MGDoFHandler<deal_II_dimension>&,
- const ComponentMask &,
- std::vector<bool>&);
-
-template void DoFTools::extract_level_dofs<MGDoFHandler<deal_II_dimension> >
-(const unsigned int level,
- const MGDoFHandler<deal_II_dimension>&,
- const BlockMask &,
- std::vector<bool>&);
-
template
void
DoFTools::extract_boundary_dofs<DoFHandler<deal_II_dimension> >
-template
-unsigned int
-DoFTools::count_dofs_with_subdomain_association<MGDoFHandler<deal_II_dimension> >
-(const MGDoFHandler<deal_II_dimension> &,
- const types::subdomain_id);
-template
-IndexSet
-DoFTools::dof_indices_with_subdomain_association<MGDoFHandler<deal_II_dimension> >
-(const MGDoFHandler<deal_II_dimension> &,
- const types::subdomain_id);
-template
-void
-DoFTools::count_dofs_with_subdomain_association<MGDoFHandler<deal_II_dimension> >
-(const MGDoFHandler<deal_II_dimension> &,
- const types::subdomain_id,
- std::vector<unsigned int> &);
-
-
template
void
DoFTools::count_dofs_per_component<DoFHandler<deal_II_dimension> > (
const ComponentMask&,
std::vector<bool>&);
-template
-void
-DoFTools::extract_level_dofs<MGDoFHandler<deal_II_dimension, deal_II_dimension+1> >
-(const unsigned int level,
- const MGDoFHandler<deal_II_dimension, deal_II_dimension+1>&,
- const BlockMask&,
- std::vector<bool>&);
-
#endif
const ComponentMask &,
std::vector<bool>&);
-template
-void
-DoFTools::extract_level_dofs<MGDoFHandler<1, 3> >
-(const unsigned int level,
- const MGDoFHandler<1,3>&,
- const BlockMask &,
- std::vector<bool>&);
-
#endif
std::vector<types::global_dof_index>&,
const std::vector<unsigned int> &);
-template
-void
-DoFTools::count_dofs_per_block<MGDoFHandler<deal_II_dimension> > (
- const MGDoFHandler<deal_II_dimension>&,
- std::vector<types::global_dof_index>&,
- const std::vector<unsigned int> &);
-
template
void
DoFTools::map_dof_to_boundary_indices<DoFHandler<deal_II_dimension> >
std::vector<types::global_dof_index>&,
const std::vector<unsigned int> &);
-template
-void
-DoFTools::count_dofs_per_block<MGDoFHandler<deal_II_dimension,deal_II_dimension+1> > (
- const MGDoFHandler<deal_II_dimension,deal_II_dimension+1>&,
- std::vector<types::global_dof_index>&,
- const std::vector<unsigned int> &);
-
#endif
std::vector<types::global_dof_index>&,
const std::vector<unsigned int> &);
-template
-void
-DoFTools::count_dofs_per_block<MGDoFHandler<1,3> > (
- const MGDoFHandler<1,3>&,
- std::vector<types::global_dof_index>&,
- const std::vector<unsigned int> &);
-
#endif
template
#include <deal.II/hp/fe_values.h>
#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <algorithm>
#include <numeric>
}
- void
- make_hp_hanging_node_constraints (const dealii::MGDoFHandler<1> &,
- ConstraintMatrix &)
- {
- // nothing to do for regular dof handlers in 1d
- }
-
-
-
- void
- make_oldstyle_hanging_node_constraints (const dealii::MGDoFHandler<1> &,
- ConstraintMatrix &,
- dealii::internal::int2type<1>)
- {
- // nothing to do for regular dof handlers in 1d
- }
-
-
void
make_hp_hanging_node_constraints (const dealii::hp::DoFHandler<1> &/*dof_handler*/,
ConstraintMatrix &/*constraints*/)
for (deal_II_dimension : DIMENSIONS)
{
-#if deal_II_dimension != 1
- template
- void
- DoFTools::make_hanging_node_constraints (const MGDoFHandler<deal_II_dimension> &dof_handler,
- ConstraintMatrix &constraints);
-
-#endif
-
#if deal_II_dimension < 3
template
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/numerics/vector_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <algorithm>
#include <numeric>
const bool,
const unsigned int);
- template void
- DoFTools::make_sparsity_pattern<MGDoFHandler<deal_II_dimension,deal_II_dimension>, SP>
- (const MGDoFHandler<deal_II_dimension,deal_II_dimension> &dof,
- SP &sparsity,
- const ConstraintMatrix &,
- const bool,
- const unsigned int);
-
template void
DoFTools::make_sparsity_pattern<DoFHandler<deal_II_dimension,deal_II_dimension>, SP>
(const DoFHandler<deal_II_dimension,deal_II_dimension>&,
const bool,
const unsigned int);
- template void
- DoFTools::make_sparsity_pattern<MGDoFHandler<deal_II_dimension,deal_II_dimension>, SP>
- (const MGDoFHandler<deal_II_dimension,deal_II_dimension>&,
- const Table<2,Coupling>&,
- SP &,
- const ConstraintMatrix &,
- const bool,
- const unsigned int);
-
template void
DoFTools::make_sparsity_pattern<DoFHandler<deal_II_dimension,deal_II_dimension>, SP>
(const DoFHandler<deal_II_dimension,deal_II_dimension> &dof_row,
#include <deal.II/fe/mapping_q.h>
#include <deal.II/fe/fe_values.h>
#include <deal.II/hp/mapping_collection.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/numerics/matrix_tools.h>
#include <boost/random/uniform_real_distribution.hpp>
-for (deal_II_dimension : DIMENSIONS)
- {
- namespace GridTools \{
- template
- std::list<std::pair<MGDoFHandler<deal_II_dimension>::cell_iterator, MGDoFHandler<deal_II_dimension>::cell_iterator> >
- get_finest_common_cells (const MGDoFHandler<deal_II_dimension> &mesh_1,
- const MGDoFHandler<deal_II_dimension> &mesh_2);
- \}
- }
-
for (X : TRIANGULATION_AND_DOFHANDLERS; deal_II_dimension : DIMENSIONS ; deal_II_space_dimension : SPACE_DIMENSIONS)
{
}
-for (deal_II_dimension : DIMENSIONS ; deal_II_space_dimension : SPACE_DIMENSIONS)
-{
-
-#if deal_II_dimension <= deal_II_space_dimension
- namespace GridTools \{
- template
- bool
- have_same_coarse_mesh (const MGDoFHandler<deal_II_dimension,deal_II_space_dimension> &mesh_1,
- const MGDoFHandler<deal_II_dimension,deal_II_space_dimension> &mesh_2);
-
- \}
-
- #endif
-}
-
-
for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
{
#if deal_II_dimension <= deal_II_space_dimension
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/grid/intergrid_map.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
DEAL_II_NAMESPACE_OPEN
## ---------------------------------------------------------------------
##
-## Copyright (C) 2012 - 2013 by the deal.II authors
+## Copyright (C) 2012 - 2013, 2015 by the deal.II authors
##
## This file is part of the deal.II library.
##
SET(_src
mg_base.cc
- mg_dof_handler.cc
mg_tools.cc
mg_transfer_block.cc
mg_transfer_component.cc
SET(_inst
mg_base.inst.in
- mg_dof_handler.inst.in
mg_tools.inst.in
mg_transfer_block.inst.in
mg_transfer_component.inst.in
+++ /dev/null
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 1998 - 2013 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 at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-
-#include <deal.II/base/memory_consumption.h>
-#include <deal.II/lac/sparse_matrix.h>
-#include <deal.II/lac/constraint_matrix.h>
-#include <deal.II/dofs/dof_levels.h>
-#include <deal.II/dofs/dof_faces.h>
-#include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
-#include <deal.II/grid/tria_levels.h>
-#include <deal.II/grid/tria_accessor.h>
-#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/grid/tria.h>
-#include <deal.II/base/geometry_info.h>
-#include <deal.II/fe/fe.h>
-#include <deal.II/base/exceptions.h>
-
-#include <algorithm>
-
-DEAL_II_NAMESPACE_OPEN
-
-namespace parallel
-{
- namespace distributed
- {
- template <int, int> class Triangulation;
- }
-}
-
-
-
-/* ------------------------ MGDoFHandler ------------------------------------- */
-
-template <int dim, int spacedim>
-const unsigned int MGDoFHandler<dim,spacedim>::dimension;
-
-
-template <int dim, int spacedim>
-MGDoFHandler<dim,spacedim>::MGDoFHandler ()
-{}
-
-
-
-template <int dim, int spacedim>
-MGDoFHandler<dim,spacedim>::MGDoFHandler (const Triangulation<dim,spacedim> &tria)
- :
- DoFHandler<dim,spacedim> (tria)
-{}
-
-
-template <int dim, int spacedim>
-MGDoFHandler<dim,spacedim>::~MGDoFHandler ()
-{}
-
-template <int dim, int spacedim>
-void MGDoFHandler<dim,spacedim>::distribute_dofs (const FiniteElement<dim,spacedim> &fe)
-{
- // first distribute global dofs
- DoFHandler<dim,spacedim>::distribute_dofs (fe);
- DoFHandler<dim,spacedim>::distribute_mg_dofs (fe);
-}
-
-
-
-template <int dim, int spacedim>
-typename MGDoFHandler<dim,spacedim>::cell_iterator
-MGDoFHandler<dim,spacedim>::begin (const unsigned int level) const
-{
- return DoFHandler<dim,spacedim>::begin_mg(level);
-}
-
-
-template <int dim, int spacedim>
-typename MGDoFHandler<dim,spacedim>::cell_iterator
-MGDoFHandler<dim,spacedim>::end (const unsigned int level) const
-{
- return DoFHandler<dim,spacedim>::end_mg(level);
-}
-
-
-template <int dim, int spacedim>
-typename MGDoFHandler<dim,spacedim>::cell_iterator
-MGDoFHandler<dim,spacedim>::end () const
-{
- return DoFHandler<dim,spacedim>::end_mg();
-}
-
-
-// explicit instantiations
-#include "mg_dof_handler.inst"
-
-
-DEAL_II_NAMESPACE_CLOSE
+++ /dev/null
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 1998 - 2013 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 at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-
-
-for (deal_II_dimension : DIMENSIONS)
- {
-template class MGDoFHandler<deal_II_dimension>;
-
-#if deal_II_dimension==1 || deal_II_dimension==2
-template class MGDoFHandler<deal_II_dimension,deal_II_dimension+1>;
-#endif
-
-#if deal_II_dimension==3
-template class MGDoFHandler<1,3>;
-#endif
- }
-
#include <deal.II/lac/block_vector.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/multigrid/mg_tools.h>
#include <deal.II/multigrid/mg_base.h>
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
PATTERN &,
const unsigned int);
-
- template void
- make_sparsity_pattern<MGDoFHandler<deal_II_dimension, deal_II_space_dimension>, PATTERN> (
- const MGDoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- PATTERN &,
- const unsigned int);
#endif
#if deal_II_dimension == deal_II_space_dimension
template void count_dofs_per_block (
const DoFHandler<deal_II_dimension>&, std::vector<std::vector<types::global_dof_index> >&,
std::vector<unsigned int>);
- template void count_dofs_per_block (
- const MGDoFHandler<deal_II_dimension>&, std::vector<std::vector<types::global_dof_index> >&,
- std::vector<unsigned int>);
#if deal_II_dimension > 1
template void make_boundary_list(
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/multigrid/mg_transfer_block.h>
#include <deal.II/multigrid/mg_transfer_block.templates.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_transfer_component.templates.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/multigrid/mg_tools.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/numerics/fe_field_function.templates.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/hp/dof_handler.h>
// ---------------------------------------------------------------------
-for (deal_II_dimension : DIMENSIONS)
-{
- namespace VectorTools \{
- template
- void interpolate_boundary_values (
- const MGDoFHandler<deal_II_dimension> &,
- const types::boundary_id,
- const Function<deal_II_dimension> &,
- ConstraintMatrix&,
- const ComponentMask &);
-
- template
- void interpolate_boundary_values (
- const MGDoFHandler<deal_II_dimension> &,
- const types::boundary_id,
- const Function<deal_II_dimension> &,
- std::map<types::global_dof_index,double> &,
- const ComponentMask &);
- \}
-}
-
-
for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS; DH : DOFHANDLER_TEMPLATES)
{
#if deal_II_dimension <= deal_II_space_dimension
check_dofs(dof);
deallog.pop();
deallog.push("MGDoF");
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
check_dofs(mgdof);
deallog.pop();
}
check_dofs(dof, (local ? 100 : 10));
deallog.pop();
deallog.push("MGDoF");
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
check_dofs(mgdof, (local ? 100 : 10));
deallog.pop();
}
+//TODO: This seems horrible memory fragmentation!
template <int dim>
- MGDoFHandler<dim>::MGVertexDoFs::MGVertexDoFs ()
+ DoFHandler<dim>::MGVertexDoFs::MGVertexDoFs ()
@@ -124,6 +125,25 @@
}
+template <int dim>
+unsigned int
-+MGDoFHandler<dim>::memory_consumption() const
++DoFHandler<dim>::memory_consumption() const
+{
+ unsigned int mem = DoFHandler<dim>::memory_consumption();
+ for (unsigned int l=0;l<mg_levels.size();++l)
#include <deal.II/base/geometry_info.h>
#include <deal.II/base/logstream.h>
#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_accessor.h>
// holds
tria.refine_global (1);
- MGDoFHandler<dim> dof_handler (tria);
+ DoFHandler<dim> dof_handler (tria);
- for (typename MGDoFHandler<dim>::cell_iterator cell = dof_handler.begin();
+ for (typename DoFHandler<dim>::cell_iterator cell = dof_handler.begin();
cell != dof_handler.end (); ++cell)
for (unsigned int child = 0; child < cell->n_children (); ++child)
Assert (cell->child (child)->parent () == cell,
tria.execute_coarsening_and_refinement ();
- for (typename MGDoFHandler<dim>::cell_iterator cell = dof_handler.begin ();
+ for (typename DoFHandler<dim>::cell_iterator cell = dof_handler.begin ();
cell != dof_handler.end(); ++cell)
for (unsigned int child = 0; child < cell->n_children (); ++child)
Assert (cell->child (child)->parent () == cell,
// ---------------------------------------------------------------------
//
-// Copyright (C) 2005 - 2013 by the deal.II authors
+// Copyright (C) 2005 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/numerics/matrix_tools.h>
#include <deal.II/numerics/data_out.h>
#include <deal.II/multigrid/multigrid.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
Triangulation<dim> triangulation;
FE_Q<dim> fe;
- MGDoFHandler<dim> mg_dof_handler;
+ DoFHandler<dim> mg_dof_handler;
SparsityPattern sparsity_pattern;
SparseMatrix<double> system_matrix;
void LaplaceProblem<dim>::setup_system ()
{
mg_dof_handler.distribute_dofs (fe);
+ mg_dof_handler.distribute_mg_dofs (fe);
deallog << " Number of degrees of freedom: "
<< mg_dof_handler.n_dofs()
std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
- typename MGDoFHandler<dim>::cell_iterator cell = mg_dof_handler.begin(),
+ typename DoFHandler<dim>::cell_iterator cell = mg_dof_handler.begin(),
endc = mg_dof_handler.end();
for (; cell!=endc; ++cell)
{
// ---------------------------------------------------------------------
//
-// Copyright (C) 2005 - 2014 by the deal.II authors
+// Copyright (C) 2005 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
// a un-hp-ified version of hp/step-16
// this version uses the new unified DoFHAndler instead
-// of the MGDoFHandler in the test step-16.cc
+// of the DoFHandler in the test step-16.cc
#include "../tests.h"
#include <deal.II/numerics/matrix_tools.h>
#include <deal.II/numerics/data_out.h>
#include <deal.II/multigrid/multigrid.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
- typename MGDoFHandler<dim>::cell_iterator cell = mg_dof_handler.begin(),
+ typename DoFHandler<dim>::cell_iterator cell = mg_dof_handler.begin(),
endc = mg_dof_handler.end();
for (; cell!=endc; ++cell)
{
// ---------------------------------------------------------------------
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2009 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include "../tests.h"
#include <deal.II/dofs/block_info.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
+#include <deal.II/dofs/dof_handler.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/grid_generator.h>
#include <deal.II/fe/fe_q.h>
void test_grid(const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
BlockInfo bi;
bi.initialize(mgdof);
bi.initialize_local(mgdof);
// same as block_info, but here we use the new DoFHandler instead
-// of the MGDoFHandler
+// of the DoFHandler
#include "../tests.h"
#include <deal.II/dofs/block_info.h>
#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/grid_generator.h>
#include <deal.II/fe/fe_q.h>
#include "../tests.h"
#include <deal.II/grid/tria.h>
#include <deal.II/grid/grid_generator.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/dofs/dof_accessor.h>
#include <dofs/dof_tools.h>
// ---------------------------------------------------------------------
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2009 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
{
deallog << fe.get_name() << std::endl;
- MGDoFHandler<dim> dof;
+ DoFHandler<dim> dof;
dof.initialize(tr, fe);
-
+ dof.distribute_mg_dofs (fe);
const unsigned int level = tr.n_levels()-1;
// ---------------------------------------------------------------------
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2009 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
{
deallog << fe.get_name() << std::endl;
- MGDoFHandler<dim> dof;
+ DoFHandler<dim> dof;
dof.initialize(tr, fe);
+ dof.distribute_mg_dofs (fe);
const unsigned int level = tr.n_levels()-1;
// ---------------------------------------------------------------------
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2009 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
{
deallog << fe.get_name() << std::endl;
- MGDoFHandler<dim> dof;
+ DoFHandler<dim> dof;
dof.initialize(tr, fe);
+ dof.distribute_mg_dofs (fe);
const unsigned int level = tr.n_levels()-1;
// ---------------------------------------------------------------------
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2009 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
{
deallog << fe.get_name() << std::endl;
- MGDoFHandler<dim> dof;
+ DoFHandler<dim> dof;
dof.initialize(tr, fe);
+ dof.distribute_mg_dofs (fe);
const unsigned int level = tr.n_levels()-1;
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
template <int dim>
void
-print_dofs (const MGDoFHandler<dim> &dof, unsigned int level)
+print_dofs (const DoFHandler<dim> &dof, unsigned int level)
{
std::vector<types::global_dof_index> v (dof.get_fe().dofs_per_cell);
- for (typename MGDoFHandler<dim>::cell_iterator cell=dof.begin(level);
+ for (typename DoFHandler<dim>::cell_iterator cell=dof.begin(level);
cell != dof.end(level); ++cell)
{
deallog << "Cell " << cell << " -- ";
template <int dim>
void
-check_renumbering(MGDoFHandler<dim> &mgdof, bool discontinuous)
+check_renumbering(DoFHandler<dim> &mgdof, bool discontinuous)
{
const FiniteElement<dim> &element = mgdof.get_fe();
DoFHandler<dim> &dof = mgdof;
if (dim==1)
tr.refine_global(2);
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
FESystem<dim> e1 (FE_Q<dim>(2), 2, FE_DGQ<dim>(1), 1);
mgdof.distribute_dofs(e1);
+ mgdof.distribute_mg_dofs(e1);
check_renumbering(mgdof, false);
mgdof.clear();
FESystem<dim> e2 (FE_DGP<dim>(2), 2, FE_DGQ<dim>(1), 1);
mgdof.distribute_dofs(e2);
+ mgdof.distribute_mg_dofs(e2);
check_renumbering(mgdof, true);
mgdof.clear();
}
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
template <int dim>
void
-print_dofs (const MGDoFHandler<dim> &dof, unsigned int level)
+print_dofs (const DoFHandler<dim> &dof, unsigned int level)
{
const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v (fe.dofs_per_cell);
fevalues = std_cxx11::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_q_points));
}
- for (typename MGDoFHandler<dim>::cell_iterator cell=dof.begin(level);
+ for (typename DoFHandler<dim>::cell_iterator cell=dof.begin(level);
cell != dof.end(level); ++cell)
{
Point<dim> p = cell->center();
template <int dim>
void
-check_renumbering(MGDoFHandler<dim> &mgdof)
+check_renumbering(DoFHandler<dim> &mgdof)
{
const FiniteElement<dim> &element = mgdof.get_fe();
DoFHandler<dim> &dof = mgdof;
tr.execute_coarsening_and_refinement ();
tr.refine_global(3-dim);
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
FE_Q<dim> q2(2);
FE_DGQ<dim> dgq1(1);
FESystem<dim> system (q2, 2, dgq1, 1);
mgdof.distribute_dofs(q2);
+ mgdof.distribute_mg_dofs(q2);
check_renumbering(mgdof);
mgdof.clear();
mgdof.distribute_dofs(dgq1);
+ mgdof.distribute_mg_dofs(dgq1);
check_renumbering(mgdof);
mgdof.clear();
mgdof.distribute_dofs(system);
+ mgdof.distribute_mg_dofs(system);
check_renumbering(mgdof);
mgdof.clear();
}
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_nedelec.h>
#include <deal.II/fe/fe_system.h>
#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <fstream>
FESystem<dim> element (FE_Q<dim>(2), 1,
FE_Nedelec<dim>(0), 1);
- MGDoFHandler<dim> dof(tr);
+ DoFHandler<dim> dof(tr);
dof.distribute_dofs(element);
+ dof.distribute_mg_dofs(element);
// try all possible block
// masks, which we encode as bit
#include <deal.II/grid/grid_tools.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/grid/tria_accessor.h>
#include <fstream>
#include <deal.II/grid/grid_tools.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <fstream>
#include <deal.II/grid/grid_tools.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <fstream>
#include <deal.II/grid/grid_tools.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <fstream>
tria[1].last_active()->set_refine_flag();
tria[1].execute_coarsening_and_refinement ();
- MGDoFHandler<dim> dh0 (tria[0]);
- MGDoFHandler<dim> dh1 (tria[1]);
+ DoFHandler<dim> dh0 (tria[0]);
+ DoFHandler<dim> dh1 (tria[1]);
typedef
- std::list<std::pair<typename MGDoFHandler<dim>::cell_iterator,
- typename MGDoFHandler<dim>::cell_iterator> >
+ std::list<std::pair<typename DoFHandler<dim>::cell_iterator,
+ typename DoFHandler<dim>::cell_iterator> >
CellList;
const CellList cell_list
#include <deal.II/grid/grid_tools.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <fstream>
#include <deal.II/grid/grid_tools.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <fstream>
#include <deal.II/grid/grid_tools.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <fstream>
#include <deal.II/grid/grid_tools.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <fstream>
tria[2].refine_global (3);
- MGDoFHandler<dim> dh0 (tria[0]);
- MGDoFHandler<dim> dh1 (tria[1]);
- MGDoFHandler<dim> dh2 (tria[2]);
+ DoFHandler<dim> dh0 (tria[0]);
+ DoFHandler<dim> dh1 (tria[1]);
+ DoFHandler<dim> dh2 (tria[2]);
- MGDoFHandler<dim> *dof_handler[3] = { &dh0, &dh1, &dh2 };
+ DoFHandler<dim> *dof_handler[3] = { &dh0, &dh1, &dh2 };
for (unsigned int i=0; i<3; ++i)
for (unsigned int j=0; j<3; ++j)
template<int dim, class MATRIX>
void build_mgmatrix(MGLevelObject<MATRIX> &A,
- const MGDoFHandler<dim> &dof,
+ const DoFHandler<dim> &dof,
const Quadrature<dim> &quadrature);
};
template<int dim, class MATRIX>
void
Helmholtz::build_mgmatrix(MGLevelObject<MATRIX>& A,
- const MGDoFHandler<dim>& dof,
+ const DoFHandler<dim>& dof,
const Quadrature<dim>& quadrature)
{
const unsigned int fe_dofs = dof.get_fe().n_dofs_per_cell();
////////////////////////////////////////////////////
DoFHandler<dim>::cell_iterator dc = dof.DoFHandler<dim>::begin();
- for (MGDoFHandler<dim>::cell_iterator c = dof.begin()
+ for (DoFHandler<dim>::cell_iterator c = dof.begin()
; c != dof.end() ; ++c, ++dc)
{
elmat.clear();
// ---------------------------------------------------------------------
//
-// Copyright (C) 2005 - 2013 by the deal.II authors
+// Copyright (C) 2005 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
-/* Author: Ralf Hartmann, 2005; the MGDoFHandler class had troubles
+/* Author: Ralf Hartmann, 2005; the DoFHandler class had troubles
when the triangulation had unused vertices before, make sure that
this is now fixed. */
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/grid_out.h>
#include <deal.II/fe/fe_dgq.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
+#include <deal.II/dofs/dof_handler.h>
#include <fstream>
GridGenerator::hyper_cube(tria);
FE_DGQ<dim> fe(1);
- MGDoFHandler<dim> dof_handler(tria);
+ DoFHandler<dim> dof_handler(tria);
tria.begin_active()->set_refine_flag();
tria.execute_coarsening_and_refinement();
// ---------------------------------------------------------------------
//
-// Copyright (C) 1998 - 2013 by the deal.II authors
+// Copyright (C) 1998 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/multigrid/mg_transfer.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <vector>
#include <fstream>
const FiniteElement<dim> &finel,
const char * /*name*/)
{
- MGDoFHandler<dim> dof(tr);
+ DoFHandler<dim> dof(tr);
dof.distribute_dofs(finel);
+ dof.distribute_mg_dofs(finel);
MGTransferPrebuilt<Vector<double> > transfer;
transfer.build_matrices(dof);
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/hp/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/hp/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/hp/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/hp/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/hp/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_dgp.h>
// ---------------------------------------------------------------------
//
-// Copyright (C) 2012 - 2013 by the deal.II authors
+// Copyright (C) 2012 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/lac/block_indices.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/grid_generator.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_tools.h>
#include <deal.II/dofs/dof_renumbering.h>
#include <deal.II/meshworker/local_results.h>
GridGenerator::hyper_cube(tr);
tr.refine_global(1);
- MGDoFHandler<dim> dof(tr);
+ DoFHandler<dim> dof(tr);
dof.distribute_dofs(fe);
+ dof.distribute_mg_dofs(fe);
dof.initialize_local_block_info();
- DoFRenumbering::component_wise(dof);
+ for (unsigned int level=0; level<tr.n_levels(); ++level)
+ DoFRenumbering::component_wise(dof, level);
deallog << "DoFs " << dof.n_dofs() << std::endl;
- typename MGDoFHandler<dim>::cell_iterator cell = dof.begin_active();
- typename MGDoFHandler<dim>::face_iterator face = cell->face(1);
- typename MGDoFHandler<dim>::cell_iterator neighbor = cell->neighbor(1);
+ typename DoFHandler<dim>::level_cell_iterator cell = dof.begin_active();
+ typename DoFHandler<dim>::face_iterator face = cell->face(1);
+ typename DoFHandler<dim>::level_cell_iterator neighbor = cell->neighbor(1);
MGLevelObject<SparsityPattern> sparsity(0, tr.n_levels()-1);
MGLevelObject<SparseMatrix<double> > matrix(0, tr.n_levels()-1);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2012 - 2013 by the deal.II authors
+// Copyright (C) 2012 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
LaplaceMatrix<dim> matrix_integrator;
- MGDoFHandler<dim> dof(tr);
+ DoFHandler<dim> dof(tr);
dof.distribute_dofs(fe);
+ dof.distribute_mg_dofs(fe);
mg::SparseMatrixCollection<double> mg;
mg.resize(0,tr.n_levels()-1);
mg.reinit(dof);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
template <int dim>
void
-test_mesh(MGDoFHandler<dim> &mgdofs)
+test_mesh(DoFHandler<dim> &mgdofs)
{
const DoFHandler<dim> &dofs = mgdofs;
MeshWorker::DoFInfo<dim> mg_dof_info(mgdofs);
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, EmptyInfoBox>
- (mgdofs.begin(), mgdofs.end(),
+ (mgdofs.begin_mg(), mgdofs.end_mg(),
mg_dof_info, info_box,
std_cxx11::bind (&Local<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
std_cxx11::bind (&Local<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
test(const FiniteElement<dim> &fe)
{
Triangulation<dim> tr;
- MGDoFHandler<dim> dofs(tr);
+ DoFHandler<dim> dofs(tr);
GridGenerator::hyper_cube(tr);
tr.refine_global(1);
deallog.push("1");
dofs.distribute_dofs(fe);
+ dofs.distribute_mg_dofs(fe);
test_mesh(dofs);
deallog.pop();
tr.begin(1)->set_refine_flag();
tr.execute_coarsening_and_refinement();
deallog.push("2");
dofs.distribute_dofs(fe);
+ dofs.distribute_mg_dofs(fe);
test_mesh(dofs);
deallog.pop();
tr.begin(2)->set_refine_flag();
tr.execute_coarsening_and_refinement();
deallog.push("3");
dofs.distribute_dofs(fe);
+ dofs.distribute_mg_dofs(fe);
test_mesh(dofs);
deallog.pop();
}
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
template <int dim>
void
-test_mesh(MGDoFHandler<dim> &mgdofs)
+test_mesh(DoFHandler<dim> &mgdofs)
{
const DoFHandler<dim> &dofs = mgdofs;
assembler.initialize(n_functionals);
MeshWorker::DoFInfo<dim> mg_dof_info(mgdofs);
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, EmptyInfoBox>
- (mgdofs.begin(), mgdofs.end(),
+ (mgdofs.begin_mg(), mgdofs.end_mg(),
mg_dof_info, info_box,
std_cxx11::bind (&Local<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
std_cxx11::bind (&Local<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
test(const FiniteElement<dim> &fe)
{
Triangulation<dim> tr;
- MGDoFHandler<dim> dofs(tr);
+ DoFHandler<dim> dofs(tr);
GridGenerator::hyper_cube(tr);
tr.refine_global(1);
deallog.push("1");
dofs.distribute_dofs(fe);
+ dofs.distribute_mg_dofs(fe);
test_mesh(dofs);
deallog.pop();
tr.begin(1)->set_refine_flag();
tr.execute_coarsening_and_refinement();
deallog.push("2");
dofs.distribute_dofs(fe);
+ dofs.distribute_mg_dofs(fe);
test_mesh(dofs);
deallog.pop();
tr.begin(2)->set_refine_flag();
tr.execute_coarsening_and_refinement();
deallog.push("3");
dofs.distribute_dofs(fe);
+ dofs.distribute_mg_dofs(fe);
test_mesh(dofs);
deallog.pop();
}
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
template <int dim>
void
-test_simple(MGDoFHandler<dim> &mgdofs)
+test_simple(DoFHandler<dim> &mgdofs)
{
SparsityPattern pattern;
SparseMatrix<double> matrix;
cell != tr.end(); ++cell, ++cn)
cell->set_user_index(cn);
- MGDoFHandler<dim> dofs(tr);
+ DoFHandler<dim> dofs(tr);
dofs.distribute_dofs(fe);
+ dofs.distribute_mg_dofs(fe);
deallog << "DoFHandler " << dofs.n_dofs() << " levels";
for (unsigned int l=0; l<tr.n_levels(); ++l)
deallog << ' ' << l << ':' << dofs.n_dofs(l);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
template <int dim>
void
-assemble(const MGDoFHandler<dim> &dof_handler,
+assemble(const DoFHandler<dim> &dof_handler,
MGLevelObject<SparseMatrix<double> > matrix,
MGLevelObject<SparseMatrix<double> > dg_up,
MGLevelObject<SparseMatrix<double> > dg_down)
template <int dim>
void
-test_simple(MGDoFHandler<dim> &mgdofs)
+test_simple(DoFHandler<dim> &mgdofs)
{
SparsityPattern pattern;
SparseMatrix<double> matrix;
cell != tr.end(); ++cell, ++cn)
cell->set_user_index(cn);
- MGDoFHandler<dim> dofs(tr);
+ DoFHandler<dim> dofs(tr);
dofs.distribute_dofs(fe);
+ dofs.distribute_mg_dofs(fe);
deallog << "DoFHandler " << dofs.n_dofs() << " levels";
for (unsigned int l=0; l<tr.n_levels(); ++l)
deallog << ' ' << l << ':' << dofs.n_dofs(l);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
template <int dim>
void
-assemble(const MGDoFHandler<dim> &dof_handler,
+assemble(const DoFHandler<dim> &dof_handler,
MGLevelObject<SparseMatrix<double> > matrix,
MGLevelObject<SparseMatrix<double> > dg_up,
MGLevelObject<SparseMatrix<double> > dg_down)
template <int dim>
void
-test_simple(MGDoFHandler<dim> &mgdofs)
+test_simple(DoFHandler<dim> &mgdofs)
{
SparsityPattern pattern;
SparseMatrix<double> matrix;
cell != tr.end(); ++cell, ++cn)
cell->set_user_index(cn);
- MGDoFHandler<dim> dofs(tr);
+ DoFHandler<dim> dofs(tr);
dofs.distribute_dofs(fe);
+ dofs.distribute_mg_dofs(fe);
deallog << "DoFHandler " << dofs.n_dofs() << " levels";
for (unsigned int l=0; l<tr.n_levels(); ++l)
deallog << ' ' << l << ':' << dofs.n_dofs(l);
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/meshworker/dof_info.h>
#include <deal.II/meshworker/integration_info.h>
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
// ---------------------------------------------------------------------
//
-// Copyright (C) 2008 - 2013 by the deal.II authors
+// Copyright (C) 2008 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/lac/trilinos_sparse_matrix.h>
#include <deal.II/lac/trilinos_precondition.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_constrained_dofs.h>
#include <deal.II/multigrid/multigrid.h>
#include <deal.II/multigrid/mg_transfer.h>
// ---------------------------------------------------------------------
//
-// Copyright (C) 2008 - 2013 by the deal.II authors
+// Copyright (C) 2008 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/lac/trilinos_sparse_matrix.h>
#include <deal.II/lac/trilinos_precondition.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_constrained_dofs.h>
#include <deal.II/multigrid/multigrid.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/meshworker/dof_info.h>
#include <deal.II/meshworker/integration_info.h>
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/meshworker/dof_info.h>
#include <deal.II/meshworker/integration_info.h>
// ---------------------------------------------------------------------
//
-// Copyright (C) 2006 - 2013 by the deal.II authors
+// Copyright (C) 2006 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_system.h>
#include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_tools.h>
#include <fstream>
typename FunctionMap<dim>::type fmap;
fmap.insert(std::make_pair(0, &zero));
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
std::vector<std::set<types::global_dof_index> > boundary_indices(tr.n_levels());
MGTools::make_boundary_list(mgdof, fmap, boundary_indices);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2006 - 2013 by the deal.II authors
+// Copyright (C) 2006 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_tools.h>
#include <fstream>
tr.execute_coarsening_and_refinement ();
tr.refine_global(1);
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
std::vector<std::vector<types::global_dof_index> > count(tr.n_levels());
MGTools::count_dofs_per_component(mgdof, count, false);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2006 - 2013 by the deal.II authors
+// Copyright (C) 2006 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_system.h>
#include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_tools.h>
#include <fstream>
template <int dim>
-void dofs(const MGDoFHandler<dim> &dof)
+void dofs(const DoFHandler<dim> &dof)
{
- typename MGDoFHandler<dim>::cell_iterator cell;
- const typename MGDoFHandler<dim>::cell_iterator end = dof.end();
+ typename DoFHandler<dim>::cell_iterator cell;
+ const typename DoFHandler<dim>::cell_iterator end = dof.end();
std::vector<types::global_dof_index> indices;
typename FunctionMap<dim>::type fmap;
fmap.insert(std::make_pair(0, &zero));
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
dofs(mgdof);
}
// ---------------------------------------------------------------------
//
-// Copyright (C) 2006 - 2013 by the deal.II authors
+// Copyright (C) 2006 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_system.h>
#include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_tools.h>
#include <fstream>
template <int dim>
-void dofs(const MGDoFHandler<dim> &dof)
+void dofs(const DoFHandler<dim> &dof)
{
- typename MGDoFHandler<dim>::cell_iterator cell;
- const typename MGDoFHandler<dim>::cell_iterator end = dof.end();
+ typename DoFHandler<dim>::cell_iterator cell;
+ const typename DoFHandler<dim>::cell_iterator end = dof.end();
std::vector<types::global_dof_index> indices;
deallog << "Level " << cell->level() << std::endl;
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
{
- typename MGDoFHandler<dim>::face_iterator face = cell->face(f);
+ typename DoFHandler<dim>::face_iterator face = cell->face(f);
face->get_mg_dof_indices(cell->level(), indices);
for (unsigned int i=0; i<GeometryInfo<dim>::vertices_per_face; ++i)
typename FunctionMap<dim>::type fmap;
fmap.insert(std::make_pair(0, &zero));
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
dofs(mgdof);
}
// ---------------------------------------------------------------------
//
-// Copyright (C) 2006 - 2014 by the deal.II authors
+// Copyright (C) 2006 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/grid_generator.h>
+#include <deal.II/dofs/dof_handler.h>
#include <deal.II/fe/fe_q.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <fstream>
#include <iomanip>
<< std::endl;
+ dof.distribute_dofs(fe);
dof.distribute_mg_dofs(fe);
deallog << "check " << dim << " level distribute "
<< dof.has_active_dofs() << ' '
// ---------------------------------------------------------------------
//
-// Copyright (C) 2010 - 2013 by the deal.II authors
+// Copyright (C) 2010 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/numerics/data_out.h>
#include <deal.II/multigrid/multigrid.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
}
template <int dim>
-void initialize (const MGDoFHandler<dim> &dof,
+void initialize (const DoFHandler<dim> &dof,
Vector<double> &u)
{
unsigned int counter=0;
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
- for (typename MGDoFHandler<dim>::active_cell_iterator
+ for (typename DoFHandler<dim>::active_cell_iterator
cell = dof.begin_active();
cell != dof.end(); ++cell)
{
template <int dim>
-void initialize (const MGDoFHandler<dim> &dof,
+void initialize (const DoFHandler<dim> &dof,
MGLevelObject<Vector<double> > &u)
{
unsigned int counter=0;
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<unsigned int> dof_indices(dofs_per_cell);
- typename MGDoFHandler<dim>::cell_iterator
+ typename DoFHandler<dim>::cell_iterator
cell = dof.begin(0);
cell->get_mg_dof_indices(dof_indices);
for (unsigned int i=0; i<dofs_per_cell; ++i)
template <int dim>
-void print_diff (const MGDoFHandler<dim> &dof_1, const MGDoFHandler<dim> &dof_2,
+void print_diff (const DoFHandler<dim> &dof_1, const DoFHandler<dim> &dof_2,
const Vector<double> &u, const Vector<double> &v)
{
Vector<double> diff;
const unsigned int dofs_per_cell = dof_1.get_fe().dofs_per_cell;
std::vector<types::global_dof_index> dof_indices_1(dofs_per_cell);
std::vector<types::global_dof_index> dof_indices_2(dofs_per_cell);
- for (typename MGDoFHandler<dim>::active_cell_iterator
+ for (typename DoFHandler<dim>::active_cell_iterator
cell_1 = dof_1.begin_active(), cell_2 = dof_2.begin_active();
cell_1 != dof_1.end(); ++cell_1, ++cell_2)
{
}
template <int dim>
-void print(const MGDoFHandler<dim> &dof, std::vector<std::vector<bool> > &interface_dofs)
+void print(const DoFHandler<dim> &dof, std::vector<std::vector<bool> > &interface_dofs)
{
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<unsigned int> dof_indices(dofs_per_cell);
{
deallog << std::endl;
deallog << "Level " << l << std::endl;
- for (typename MGDoFHandler<dim>::cell_iterator
+ for (typename DoFHandler<dim>::cell_iterator
cell = dof.begin(l);
cell != dof.end(l); ++cell)
{
Triangulation<dim> triangulation;
FESystem<dim> fe;
- MGDoFHandler<dim> mg_dof_handler;
- MGDoFHandler<dim> mg_dof_handler_renumbered;
+ DoFHandler<dim> mg_dof_handler;
+ DoFHandler<dim> mg_dof_handler_renumbered;
MGLevelObject<SparsityPattern> mg_sparsity_renumbered;
MGLevelObject<SparseMatrix<double> > mg_matrices_renumbered;
template <int dim>
void LaplaceProblem<dim>::setup_system ()
{
- mg_dof_handler.distribute_dofs (fe);
+ mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs (fe);
mg_dof_handler_renumbered.distribute_dofs (fe);
+ mg_dof_handler_renumbered.distribute_mg_dofs (fe);
std::vector<unsigned int> block_component (2*dim,0);
for (unsigned int c=dim; c<2*dim; ++c)
const unsigned int dofs_per_cell =
mg_dof_handler_renumbered.get_fe().dofs_per_cell;
std::vector<unsigned int> dof_indices(dofs_per_cell);
- for (typename MGDoFHandler<dim>::cell_iterator
+ for (typename DoFHandler<dim>::cell_iterator
cell = mg_dof_handler_renumbered.begin();
cell != mg_dof_handler_renumbered.end(); ++cell)
{
// ---------------------------------------------------------------------
//
-// Copyright (C) 2013 by the deal.II authors
+// Copyright (C) 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/meshworker/output.h>
#include <deal.II/multigrid/multigrid.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
}
template <int dim>
-void initialize (const MGDoFHandler<dim> &dof,
+void initialize (const DoFHandler<dim> &dof,
Vector<double> &u)
{
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
- for (typename MGDoFHandler<dim>::active_cell_iterator
+ for (typename DoFHandler<dim>::active_cell_iterator
cell = dof.begin_active();
cell != dof.end(); ++cell)
{
template <int dim>
-void initialize (const MGDoFHandler<dim> &dof,
+void initialize (const DoFHandler<dim> &dof,
MGLevelObject<Vector<double> > &u)
{
unsigned int counter=0;
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
- typename MGDoFHandler<dim>::cell_iterator
+ typename DoFHandler<dim>::cell_iterator
cell = dof.begin(0);
cell->get_mg_dof_indices(dof_indices);
for (unsigned int i=0; i<dofs_per_cell; ++i)
template <int dim>
-void diff (Vector<double> &diff, const MGDoFHandler<dim> &dof,
+void diff (Vector<double> &diff, const DoFHandler<dim> &dof,
const Vector<double> &v, const unsigned int level)
{
diff.reinit (v);
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<unsigned int> mg_dof_indices(dofs_per_cell);
const unsigned int n_comp = dof.get_fe().n_components();
- for (typename MGDoFHandler<dim>::cell_iterator
+ for (typename DoFHandler<dim>::cell_iterator
cell= dof.begin(level);
cell != dof.end(level); ++cell)
{
private:
void setup_system ();
void test_boundary ();
- void output_gpl(const MGDoFHandler<dim> &dof,
+ void output_gpl(const DoFHandler<dim> &dof,
MGLevelObject<Vector<double> > &v);
void refine_local ();
Triangulation<dim> triangulation;
const MappingQ1<dim> mapping;
FESystem<dim> fe;
- MGDoFHandler<dim> mg_dof_handler_renumbered;
+ DoFHandler<dim> mg_dof_handler_renumbered;
const unsigned int degree;
std::vector<std::set<types::global_dof_index> >
void LaplaceProblem<dim>::setup_system ()
{
mg_dof_handler_renumbered.distribute_dofs (fe);
+ mg_dof_handler_renumbered.distribute_mg_dofs (fe);
const unsigned int nlevels = triangulation.n_levels();
template <int dim>
void
-LaplaceProblem<dim>::output_gpl(const MGDoFHandler<dim> &dof,
+LaplaceProblem<dim>::output_gpl(const DoFHandler<dim> &dof,
MGLevelObject<Vector<double> > &v)
{
MeshWorker::IntegrationInfoBox<dim> info_box;
{
OutputCreator<dim> matrix_integrator;
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> > (
- dof.begin(l), dof.end(l),
+ dof.begin_mg(l), dof.end_mg(l),
dof_info, info_box,
std_cxx11::bind(&OutputCreator<dim>::cell, &matrix_integrator, std_cxx11::_1, std_cxx11::_2),
0,
// ---------------------------------------------------------------------
//
-// Copyright (C) 2013 by the deal.II authors
+// Copyright (C) 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/meshworker/output.h>
#include <deal.II/multigrid/multigrid.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
}
template <int dim>
-void initialize (const MGDoFHandler<dim> &dof,
+void initialize (const DoFHandler<dim> &dof,
Vector<double> &u)
{
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
- for (typename MGDoFHandler<dim>::active_cell_iterator
+ for (typename DoFHandler<dim>::active_cell_iterator
cell = dof.begin_active();
cell != dof.end(); ++cell)
{
template <int dim>
-void initialize (const MGDoFHandler<dim> &dof,
+void initialize (const DoFHandler<dim> &dof,
MGLevelObject<Vector<double> > &u)
{
unsigned int counter=0;
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
- typename MGDoFHandler<dim>::cell_iterator
+ typename DoFHandler<dim>::cell_iterator
cell = dof.begin(0);
cell->get_mg_dof_indices(dof_indices);
for (unsigned int i=0; i<dofs_per_cell; ++i)
template <int dim>
-void diff (Vector<double> &diff, const MGDoFHandler<dim> &dof,
+void diff (Vector<double> &diff, const DoFHandler<dim> &dof,
const Vector<double> &v, const unsigned int level)
{
diff.reinit (v);
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<types::global_dof_index> mg_dof_indices(dofs_per_cell);
const unsigned int n_comp = dof.get_fe().n_components();
- for (typename MGDoFHandler<dim>::cell_iterator
+ for (typename DoFHandler<dim>::cell_iterator
cell= dof.begin(level);
cell != dof.end(level); ++cell)
{
}
template <int dim>
-void diff (Vector<double> &diff, const MGDoFHandler<dim> &dof_1, const MGDoFHandler<dim> &dof_2,
+void diff (Vector<double> &diff, const DoFHandler<dim> &dof_1, const DoFHandler<dim> &dof_2,
const Vector<double> &u, const Vector<double> &v, const unsigned int level)
{
diff.reinit (u);
const unsigned int dofs_per_cell = dof_1.get_fe().dofs_per_cell;
std::vector<unsigned int> dof_indices_1(dofs_per_cell);
std::vector<unsigned int> dof_indices_2(dofs_per_cell);
- for (typename MGDoFHandler<dim>::cell_iterator
+ for (typename DoFHandler<dim>::cell_iterator
cell_1 = dof_1.begin(level), cell_2 = dof_2.begin(level);
cell_1 != dof_1.end(level); ++cell_1, ++cell_2)
{
}
template <int dim>
-void print(const MGDoFHandler<dim> &dof, std::vector<std::vector<bool> > &interface_dofs)
+void print(const DoFHandler<dim> &dof, std::vector<std::vector<bool> > &interface_dofs)
{
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
{
deallog << std::endl;
deallog << "Level " << l << std::endl;
- for (typename MGDoFHandler<dim>::cell_iterator
+ for (typename DoFHandler<dim>::cell_iterator
cell = dof.begin(l);
cell != dof.end(l); ++cell)
{
private:
void setup_system ();
void test ();
- void output_gpl(const MGDoFHandler<dim> &dof,
+ void output_gpl(const DoFHandler<dim> &dof,
MGLevelObject<Vector<double> > &v);
void refine_local ();
Triangulation<dim> triangulation;
const MappingQ1<dim> mapping;
FESystem<dim> fe;
- MGDoFHandler<dim> mg_dof_handler;
- MGDoFHandler<dim> mg_dof_handler_renumbered;
+ DoFHandler<dim> mg_dof_handler;
+ DoFHandler<dim> mg_dof_handler_renumbered;
const unsigned int degree;
std::vector<std::set<unsigned int> >
template <int dim>
void LaplaceProblem<dim>::setup_system ()
{
- mg_dof_handler.distribute_dofs (fe);
+ mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs (fe);
mg_dof_handler_renumbered.distribute_dofs (fe);
+ mg_dof_handler_renumbered.distribute_mg_dofs (fe);
const unsigned int nlevels = triangulation.n_levels();
template <int dim>
void
-LaplaceProblem<dim>::output_gpl(const MGDoFHandler<dim> &dof,
+LaplaceProblem<dim>::output_gpl(const DoFHandler<dim> &dof,
MGLevelObject<Vector<double> > &v)
{
MeshWorker::IntegrationInfoBox<dim> info_box;
{
OutputCreator<dim> matrix_integrator;
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> > (
- dof.begin(l), dof.end(l),
+ dof.begin_mg(l), dof.end_mg(l),
dof_info, info_box,
std_cxx11::bind(&OutputCreator<dim>::cell, &matrix_integrator, std_cxx11::_1, std_cxx11::_2),
0,
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
// check the new DoFRenumbering::component_wise function that handles
-// MGDoFHandlers and renumbers all MG and non-MG dofs
+// DoFHandlers and renumbers all MG and non-MG dofs
#include "../tests.h"
#include <deal.II/base/logstream.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <fstream>
tr.begin_active()->set_refine_flag();
tr.execute_coarsening_and_refinement ();
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
DoFRenumbering::component_wise (mgdof);
+ for (unsigned int l=0; l<tr.n_levels(); ++l)
+ DoFRenumbering::component_wise (mgdof, l);
+
- typename MGDoFHandler<dim>::cell_iterator
- cell = mgdof.begin(),
- endc = mgdof.end();
+ typename DoFHandler<dim>::level_cell_iterator
+ cell = mgdof.begin_mg(),
+ endc = mgdof.end_mg();
std::vector<types::global_dof_index> local_dof_indices (fe.dofs_per_cell);
std::vector<types::global_dof_index> mg_dof_indices (fe.dofs_per_cell);
for (; cell!=endc; ++cell)
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Until version 1.50 of mg_dof_handler.cc, the
-// MGDoFHandler::renumbering function could not handle coarsened grids
+// DoFHandler::renumbering function could not handle coarsened grids
// (unused cells). Check that this works now.
#include "../tests.h"
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <fstream>
cell->set_coarsen_flag();
tria.execute_coarsening_and_refinement ();
- MGDoFHandler<dim> mg_dof_handler(tria);
+ DoFHandler<dim> mg_dof_handler(tria);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
Point<dim> a;
a(0)=1;
for (unsigned int level=0; level<tria.n_levels(); ++level)
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Until version 1.50 of mg_dof_handler.cc, the
-// MGDoFHandler::distribute_dofs function in 1d and 3d could not
+// DoFHandler::distribute_dofs function in 1d and 3d could not
// handle coarsened grids (unused vertices). Also, the
-// MGDoFHandler::renumbering function could not handle coarsened grids
+// DoFHandler::renumbering function could not handle coarsened grids
// (unused vertices, unused faces). Check that all this works now.
#include "../tests.h"
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <fstream>
cell->set_coarsen_flag();
tria.execute_coarsening_and_refinement ();
- MGDoFHandler<dim> mg_dof_handler(tria);
+ DoFHandler<dim> mg_dof_handler(tria);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
for (unsigned int level=0; level<tria.n_levels(); ++level)
{
const types::global_dof_index n_dofs=mg_dof_handler.n_dofs(level);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/numerics/data_out.h>
#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/multigrid.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
Triangulation<dim> triangulation;
FE_Q<dim> fe;
- MGDoFHandler<dim> mg_dof_handler;
+ DoFHandler<dim> mg_dof_handler;
SparsityPattern sparsity_pattern;
SparseMatrix<double> system_matrix;
template <int dim>
void LaplaceProblem<dim>::setup_system ()
{
- mg_dof_handler.distribute_dofs (fe);
+ mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs (fe);
deallog << "Number of degrees of freedom: "
<< mg_dof_handler.n_dofs();
const Coefficient<dim> coefficient;
std::vector<double> coefficient_values (n_q_points);
- typename MGDoFHandler<dim>::active_cell_iterator
+ typename DoFHandler<dim>::active_cell_iterator
cell = mg_dof_handler.begin_active(),
endc = mg_dof_handler.end();
for (; cell!=endc; ++cell)
assembler.initialize_interfaces(mg_interface_in, mg_interface_out);
MeshWorker::integration_loop<dim, dim> (
- mg_dof_handler.begin(), mg_dof_handler.end(),
+ mg_dof_handler.begin_mg(), mg_dof_handler.end_mg(),
dof_info, info_box, matrix_integrator, assembler);
const unsigned int nlevels = triangulation.n_levels();
boundary_interface_constraints[level].close ();
}
- typename MGDoFHandler<dim>::cell_iterator cell = mg_dof_handler.begin(),
- endc = mg_dof_handler.end();
+ typename DoFHandler<dim>::level_cell_iterator cell = mg_dof_handler.begin_mg(),
+ endc = mg_dof_handler.end_mg();
for (; cell!=endc; ++cell)
{
// ---------------------------------------------------------------------
//
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/numerics/data_out.h>
#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/multigrid.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
Triangulation<dim> triangulation;
FE_Q<dim> fe;
- MGDoFHandler<dim> mg_dof_handler;
+ DoFHandler<dim> mg_dof_handler;
SparsityPattern sparsity_pattern;
SparseMatrix<double> system_matrix;
template <int dim>
void LaplaceProblem<dim>::setup_system ()
{
- mg_dof_handler.distribute_dofs (fe);
+ mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs (fe);
deallog << "Number of degrees of freedom: "
<< mg_dof_handler.n_dofs();
const Coefficient<dim> coefficient;
std::vector<double> coefficient_values (n_q_points);
- typename MGDoFHandler<dim>::active_cell_iterator
+ typename DoFHandler<dim>::active_cell_iterator
cell = mg_dof_handler.begin_active(),
endc = mg_dof_handler.end();
for (; cell!=endc; ++cell)
assembler.initialize_interfaces(mg_interface_in, mg_interface_out);
MeshWorker::integration_loop<dim, dim> (
- mg_dof_handler.begin(), mg_dof_handler.end(),
+ mg_dof_handler.begin_mg(), mg_dof_handler.end_mg(),
dof_info, info_box, matrix_integrator, assembler);
const unsigned int nlevels = triangulation.n_levels();
boundary_interface_constraints[level].close ();
}
- typename MGDoFHandler<dim>::cell_iterator cell = mg_dof_handler.begin(),
- endc = mg_dof_handler.end();
+ typename DoFHandler<dim>::level_cell_iterator cell = mg_dof_handler.begin_mg(),
+ endc = mg_dof_handler.end_mg();
for (; cell!=endc; ++cell)
{
// ---------------------------------------------------------------------
//
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/numerics/data_out.h>
#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/multigrid.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
Triangulation<dim> triangulation;
FE_Q<dim> fe;
- MGDoFHandler<dim> mg_dof_handler;
+ DoFHandler<dim> mg_dof_handler;
SparsityPattern sparsity_pattern;
SparseMatrix<double> system_matrix;
template <int dim>
void LaplaceProblem<dim>::setup_system ()
{
- mg_dof_handler.distribute_dofs (fe);
+ mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs (fe);
deallog << "Number of degrees of freedom: "
<< mg_dof_handler.n_dofs();
const Coefficient<dim> coefficient;
std::vector<double> coefficient_values (n_q_points);
- typename MGDoFHandler<dim>::active_cell_iterator
+ typename DoFHandler<dim>::active_cell_iterator
cell = mg_dof_handler.begin_active(),
endc = mg_dof_handler.end();
for (; cell!=endc; ++cell)
boundary_interface_constraints[level].close ();
}
- typename MGDoFHandler<dim>::cell_iterator cell = mg_dof_handler.begin(),
+ typename DoFHandler<dim>::cell_iterator cell = mg_dof_handler.begin(),
endc = mg_dof_handler.end();
for (; cell!=endc; ++cell)
// problem under consideration. In that case,
// we can use the MGTransferPrebuilt class
// that, given the constraints on the global
-// level and an MGDoFHandler object computes
+// level and an DoFHandler object computes
// the matrices corresponding to these
// transfer operators.
//
// exception of two minor differences: The
// KellyErrorEstimator::estimate function
// wants an argument of type DoFHandler, not
-// MGDoFHandler, and so we have to cast from
+// DoFHandler, and so we have to cast from
// derived to base class; and we generate
// output in VTK format, to use the more
// modern visualization programs available
// ---------------------------------------------------------------------
//
-// Copyright (C) 2013 by the deal.II authors
+// Copyright (C) 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/meshworker/dof_info.h>
#include <deal.II/meshworker/integration_info.h>
Triangulation<dim> triangulation;
const MappingQ1<dim> mapping;
const FiniteElement<dim> &fe;
- MGDoFHandler<dim> mg_dof_handler;
+ DoFHandler<dim> mg_dof_handler;
DoFHandler<dim> &dof_handler;
SparsityPattern sparsity;
InteriorPenaltyProblem<dim>::setup_system()
{
dof_handler.distribute_dofs(fe);
+ dof_handler.distribute_mg_dofs(fe);
types::global_dof_index n_dofs = dof_handler.n_dofs();
solution.reinit(n_dofs);
right_hand_side.reinit(n_dofs);
MatrixIntegrator<dim> integrator;
MeshWorker::integration_loop<dim, dim> (
- mg_dof_handler.begin(), mg_dof_handler.end(),
+ mg_dof_handler.begin_mg(), mg_dof_handler.end_mg(),
dof_info, info_box,
integrator, assembler);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2013 by the deal.II authors
+// Copyright (C) 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/meshworker/dof_info.h>
#include <deal.II/meshworker/integration_info.h>
Triangulation<dim> triangulation;
const MappingQ1<dim> mapping;
const FiniteElement<dim> &fe;
- MGDoFHandler<dim> mg_dof_handler;
+ DoFHandler<dim> mg_dof_handler;
DoFHandler<dim> &dof_handler;
MGConstrainedDoFs mg_constraints;
InteriorPenaltyProblem<dim>::setup_system()
{
dof_handler.distribute_dofs(fe);
+ dof_handler.distribute_mg_dofs(fe);
unsigned int n_dofs = dof_handler.n_dofs();
solution.reinit(n_dofs);
right_hand_side.reinit(n_dofs);
MatrixIntegrator<dim> integrator;
MeshWorker::integration_loop<dim, dim> (
- mg_dof_handler.begin(), mg_dof_handler.end(),
+ mg_dof_handler.begin_mg(), mg_dof_handler.end_mg(),
dof_info, info_box,
integrator, assembler);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2013 by the deal.II authors
+// Copyright (C) 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_system.h>
#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/meshworker/dof_info.h>
#include <deal.II/meshworker/integration_info.h>
Triangulation<dim> triangulation;
const MappingQ1<dim> mapping;
const FiniteElement<dim> &fe;
- MGDoFHandler<dim> mg_dof_handler;
+ DoFHandler<dim> mg_dof_handler;
DoFHandler<dim> &dof_handler;
SparsityPattern sparsity;
InteriorPenaltyProblem<dim>::setup_system()
{
dof_handler.distribute_dofs(fe);
+ dof_handler.distribute_mg_dofs(fe);
types::global_dof_index n_dofs = dof_handler.n_dofs();
solution.reinit(n_dofs);
right_hand_side.reinit(n_dofs);
MatrixIntegrator<dim> integrator;
MeshWorker::integration_loop<dim, dim> (
- mg_dof_handler.begin(), mg_dof_handler.end(),
+ mg_dof_handler.begin_mg(), mg_dof_handler.end_mg(),
dof_info, info_box,
integrator, assembler);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2010 - 2013 by the deal.II authors
+// Copyright (C) 2010 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_dgp.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/meshworker/dof_info.h>
#include <deal.II/meshworker/integration_info.h>
Triangulation<dim> triangulation;
const MappingQ1<dim> mapping;
const FiniteElement<dim> &fe;
- MGDoFHandler<dim> mg_dof_handler;
+ DoFHandler<dim> mg_dof_handler;
DoFHandler<dim> &dof_handler;
SparsityPattern sparsity;
InteriorPenaltyProblem<dim>::setup_system()
{
dof_handler.distribute_dofs(fe);
+ dof_handler.distribute_mg_dofs(fe);
unsigned int n_dofs = dof_handler.n_dofs();
solution.reinit(n_dofs);
right_hand_side.reinit(n_dofs);
MatrixIntegrator<dim> integrator;
MeshWorker::integration_loop<dim, dim> (
- mg_dof_handler.begin(), mg_dof_handler.end(),
+ mg_dof_handler.begin_mg(), mg_dof_handler.end_mg(),
dof_info, info_box,
integrator, assembler);
}
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
MGTransferPrebuilt<Vector<double> > transfer;
transfer.build_matrices(mgdof);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
refine_mesh(tr);
refine_mesh(tr);
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
MGTransferPrebuilt<Vector<double> > transfer;
transfer.build_matrices(mgdof);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
}
template <int dim>
-void initialize (const MGDoFHandler<dim> &dof,
+void initialize (const DoFHandler<dim> &dof,
Vector<double> &u)
{
unsigned int counter=0;
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
- for (typename MGDoFHandler<dim>::active_cell_iterator
+ for (typename DoFHandler<dim>::active_cell_iterator
cell = dof.begin_active();
cell != dof.end(); ++cell)
{
}
template <int dim>
-void initialize (const MGDoFHandler<dim> &dof,
+void initialize (const DoFHandler<dim> &dof,
MGLevelObject<Vector<double> > &u)
{
unsigned int counter=0;
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
- typename MGDoFHandler<dim>::cell_iterator
+ typename DoFHandler<dim>::cell_iterator
cell = dof.begin(0);
cell->get_mg_dof_indices(dof_indices);
for (unsigned int i=0; i<dofs_per_cell; ++i)
}
template <int dim>
-void print (const MGDoFHandler<dim> &dof,
+void print (const DoFHandler<dim> &dof,
MGLevelObject<Vector<double> > &u)
{
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
{
deallog << std::endl;
deallog << "Level " << l << std::endl;
- for (typename MGDoFHandler<dim>::cell_iterator
+ for (typename DoFHandler<dim>::cell_iterator
cell = dof.begin(l);
cell != dof.end(l); ++cell)
{
}
template <int dim>
-void print_diff (const MGDoFHandler<dim> &dof_1, const MGDoFHandler<dim> &dof_2,
+void print_diff (const DoFHandler<dim> &dof_1, const DoFHandler<dim> &dof_2,
const Vector<double> &u, const Vector<double> &v)
{
Vector<double> diff;
const unsigned int dofs_per_cell = dof_1.get_fe().dofs_per_cell;
std::vector<types::global_dof_index> dof_indices_1(dofs_per_cell);
std::vector<types::global_dof_index> dof_indices_2(dofs_per_cell);
- for (typename MGDoFHandler<dim>::active_cell_iterator
+ for (typename DoFHandler<dim>::active_cell_iterator
cell_1 = dof_1.begin_active(), cell_2 = dof_2.begin_active();
cell_1 != dof_1.end(); ++cell_1, ++cell_2)
{
refine_mesh(tr);
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
- MGDoFHandler<dim> mgdof_renumbered(tr);
+ DoFHandler<dim> mgdof_renumbered(tr);
mgdof_renumbered.distribute_dofs(fe);
+ mgdof_renumbered.distribute_mg_dofs(fe);
std::vector<unsigned int> block_component (4,0);
block_component[2] = 1;
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer_block.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
reinit_vector_by_blocks (
- const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+ 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)
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
DoFHandler<dim> &dof=mgdof;
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
DoFRenumbering::component_wise(mgdof);
vector<types::global_dof_index> ndofs(fe.n_blocks());
DoFTools::count_dofs_per_block(mgdof, ndofs);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer_block.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
reinit_vector_by_blocks (
- const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+ 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)
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
DoFHandler<dim> &dof=mgdof;
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
DoFRenumbering::component_wise(mgdof);
vector<types::global_dof_index> ndofs(fe.n_blocks());
DoFTools::count_dofs_per_block(mgdof, ndofs);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_block.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
reinit_vector_by_blocks (
- const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+ 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::MGDoFHandler<dim,spacedim> &mg_dof,
+ 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)
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
DoFHandler<dim> &dof=mgdof;
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
// Make sure all orderings are the
// same
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
tr.begin(2)->set_refine_flag();
tr.execute_coarsening_and_refinement();
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
MGTransferPrebuilt<Vector<double> > transfer;
transfer.build_matrices(mgdof);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
#include <deal.II/multigrid/mg_constrained_dofs.h>
tr.begin(2)->set_refine_flag();
tr.execute_coarsening_and_refinement();
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
ConstraintMatrix hanging_node_constraints;
DoFTools::make_hanging_node_constraints (mgdof, hanging_node_constraints);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
#include <deal.II/multigrid/mg_constrained_dofs.h>
tr.begin(2)->set_refine_flag();
tr.execute_coarsening_and_refinement();
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
ConstraintMatrix hanging_node_constraints;
DoFTools::make_hanging_node_constraints (mgdof, hanging_node_constraints);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
DoFHandler<dim> &dof=mgdof;
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
DoFRenumbering::component_wise(static_cast<DoFHandler<dim>&>(mgdof),
target_component);
vector<types::global_dof_index> ndofs(*std::max_element (target_component.begin(),
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
DoFRenumbering::component_wise (mg_dof_handler);
for (unsigned int level=0; level<tr.n_levels(); ++level)
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
DoFRenumbering::component_wise (mg_dof_handler);
for (unsigned int level=0; level<tr.n_levels(); ++level)
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
DoFRenumbering::component_wise (mg_dof_handler);
for (unsigned int level=0; level<tr.n_levels(); ++level)
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
std::vector<unsigned int> block_component(3,0);
block_component[2]=1;
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
std::vector<unsigned int> block_component(5,0);
block_component[2]=1;
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
subdivisions, bottom_left, top_right, true);
refine_mesh(tr);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
deallog << "Global dofs: " << mg_dof_handler.n_dofs() << std::endl;
for (unsigned int l=0; l<tr.n_levels(); ++l)
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
subdivisions, bottom_left, top_right, true);
refine_mesh(tr);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
deallog << "Global dofs: " << mg_dof_handler.n_dofs() << std::endl;
for (unsigned int l=0; l<tr.n_levels(); ++l)
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
subdivisions, bottom_left, top_right, true);
refine_mesh(tr);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
deallog << "Global dofs: " << mg_dof_handler.n_dofs() << std::endl;
for (unsigned int l=0; l<tr.n_levels(); ++l)
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
subdivisions, bottom_left, top_right, true);
refine_mesh(tr);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
deallog << "Global dofs: " << mg_dof_handler.n_dofs() << std::endl;
for (unsigned int l=0; l<tr.n_levels(); ++l)
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
subdivisions, bottom_left, top_right, true);
refine_mesh(tr);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
deallog << "Global dofs: " << mg_dof_handler.n_dofs() << std::endl;
for (unsigned int l=0; l<tr.n_levels(); ++l)
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
subdivisions, bottom_left, top_right, true);
refine_mesh(tr);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
deallog << "Global dofs: " << mg_dof_handler.n_dofs() << std::endl;
for (unsigned int l=0; l<tr.n_levels(); ++l)
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
subdivisions, bottom_left, top_right, true);
refine_mesh(tr);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
std::vector<unsigned int> block_selected(3,0);
block_selected[2] = 1;
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, typename number, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<dim,spacedim> &mg_dof,
+reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
MGLevelObject<dealii::Vector<number> > &v)
{
for (unsigned int level=v.min_level();
subdivisions, bottom_left, top_right, true);
refine_mesh(tr);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
std::vector<unsigned int> block_selected(3,0);
block_selected[2] = 1;
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_component.h>
#include <deal.II/multigrid/mg_tools.h>
// grid_out.write_eps (tr, grid_output);
- MGDoFHandler<dim> mg_dof_handler(tr);
+ DoFHandler<dim> mg_dof_handler(tr);
mg_dof_handler.distribute_dofs(fe);
+ mg_dof_handler.distribute_mg_dofs(fe);
std::vector<unsigned int> block_component(5,0);
block_component[2]=1;
#include <deal.II/fe/fe_raviart_thomas.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_tools.h>
template <int dim, int spacedim>
void
-reinit_vector (const dealii::MGDoFHandler<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 =
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- MGDoFHandler<dim> mgdof(tr);
+ DoFHandler<dim> mgdof(tr);
mgdof.distribute_dofs(fe);
+ mgdof.distribute_mg_dofs(fe);
MGTransferPrebuilt<TrilinosWrappers::MPI::Vector> transfer;
transfer.build_matrices(mgdof);