mg_constrained_dofs.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2010 - 2016 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 dealii__mg_constrained_dofs_h
#define dealii__mg_constrained_dofs_h

#include <deal.II/base/config.h>
#include <deal.II/base/subscriptor.h>

#include <deal.II/multigrid/mg_tools.h>

#include <vector>
#include <set>

DEAL_II_NAMESPACE_OPEN

template <int dim, int spacedim> class DoFHandler;
template <int dim, typename Number> struct FunctionMap;


class MGConstrainedDoFs : public Subscriptor
{
public:

  typedef std::vector<std::set<types::global_dof_index> >::size_type size_dof;
  template <int dim, int spacedim>
  void initialize (const DoFHandler<dim,spacedim> &dof);

  template <int dim, int spacedim>
  void initialize(const DoFHandler<dim,spacedim> &dof,
                  const typename FunctionMap<dim>::type &function_map,
                  const ComponentMask &component_mask = ComponentMask()) DEAL_II_DEPRECATED;

  template <int dim, int spacedim>
  void make_zero_boundary_constraints(const DoFHandler<dim,spacedim> &dof,
                                      const std::set<types::boundary_id> &boundary_ids,
                                      const ComponentMask &component_mask = ComponentMask());

  void clear();

  bool is_boundary_index (const unsigned int level,
                          const types::global_dof_index index) const;

  bool at_refinement_edge (const unsigned int level,
                           const types::global_dof_index index) const;

  const IndexSet &
  get_boundary_indices (const unsigned int level) const;


  const IndexSet &
  get_refinement_edge_indices (unsigned int level) const;


  bool have_boundary_indices () const;

private:

  std::vector<IndexSet> boundary_indices;

  std::vector<IndexSet> refinement_edge_indices;
};


template <int dim, int spacedim>
inline
void
MGConstrainedDoFs::initialize(const DoFHandler<dim,spacedim> &dof)
{
  boundary_indices.clear();
  refinement_edge_indices.clear();

  const unsigned int nlevels = dof.get_triangulation().n_global_levels();

  //At this point refinement_edge_indices is empty.
  refinement_edge_indices.resize(nlevels);
  for (unsigned int l=0; l<nlevels; ++l)
    refinement_edge_indices[l] = IndexSet(dof.n_dofs(l));

  MGTools::extract_inner_interface_dofs (dof, refinement_edge_indices);
}


template <int dim, int spacedim>
inline
void
MGConstrainedDoFs::initialize(const DoFHandler<dim,spacedim> &dof,
                              const typename FunctionMap<dim>::type &function_map,
                              const ComponentMask &component_mask)
{
  initialize (dof);

  // allocate an IndexSet for each global level. Contents will be
  // overwritten inside make_boundary_list.
  const unsigned int n_levels = dof.get_triangulation().n_global_levels();
  //At this point boundary_indices is empty.
  boundary_indices.resize(n_levels);

  MGTools::make_boundary_list (dof,
                               function_map,
                               boundary_indices,
                               component_mask);
}


template <int dim, int spacedim>
inline
void
MGConstrainedDoFs::make_zero_boundary_constraints(const DoFHandler<dim,spacedim> &dof,
                                                  const std::set<types::boundary_id> &boundary_ids,
                                                  const ComponentMask &component_mask)
{
  // allocate an IndexSet for each global level. Contents will be
  // overwritten inside make_boundary_list.
  const unsigned int n_levels = dof.get_triangulation().n_global_levels();
  Assert(boundary_indices.size() == 0 || boundary_indices.size() == n_levels,
         ExcInternalError());
  boundary_indices.resize(n_levels);

  MGTools::make_boundary_list (dof,
                               boundary_ids,
                               boundary_indices,
                               component_mask);
}


inline
void
MGConstrainedDoFs::clear()
{
  boundary_indices.clear();
  refinement_edge_indices.clear();
}


inline
bool
MGConstrainedDoFs::is_boundary_index (const unsigned int level,
                                      const types::global_dof_index index) const
{
  if (boundary_indices.size() == 0)
    return false;

  AssertIndexRange(level, boundary_indices.size());
  return boundary_indices[level].is_element(index);
}

inline
bool
MGConstrainedDoFs::at_refinement_edge (const unsigned int level,
                                       const types::global_dof_index index) const
{
  AssertIndexRange(level, refinement_edge_indices.size());

  return refinement_edge_indices[level].is_element(index);
}




inline
const IndexSet &
MGConstrainedDoFs::get_boundary_indices (const unsigned int level) const
{
  AssertIndexRange(level, boundary_indices.size());
  return boundary_indices[level];
}



inline
const IndexSet &
MGConstrainedDoFs::get_refinement_edge_indices (unsigned int level) const
{
  AssertIndexRange(level, refinement_edge_indices.size());
  return refinement_edge_indices[level];
}




inline
bool
MGConstrainedDoFs::have_boundary_indices () const
{
  return boundary_indices.size()!=0;
}


DEAL_II_NAMESPACE_CLOSE

#endif