matrix_tools.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 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__matrix_tools_h
#define dealii__matrix_tools_h


#include <deal.II/base/config.h>
#include <deal.II/base/function.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/thread_management.h>
#include <deal.II/lac/constraint_matrix.h>
#include <deal.II/dofs/function_map.h>

#include <map>

DEAL_II_NAMESPACE_OPEN


// forward declarations
template <int dim> class Quadrature;


template<typename number> class Vector;
template<typename number> class FullMatrix;
template<typename number> class SparseMatrix;

template <typename number> class BlockSparseMatrix;
template <typename Number> class BlockVector;

template <int dim, int spacedim> class Mapping;
template <int dim, int spacedim> class DoFHandler;
template <int dim, int spacedim> class FEValues;

namespace hp
{
  template <int> class QCollection;
  template <int, int> class MappingCollection;
  template <int, int> class DoFHandler;
}


#ifdef DEAL_II_WITH_PETSC
namespace PETScWrappers
{
  class SparseMatrix;
  class Vector;
  namespace MPI
  {
    class SparseMatrix;
    class BlockSparseMatrix;
    class Vector;
    class BlockVector;
  }
}
#endif

#ifdef DEAL_II_WITH_TRILINOS
namespace TrilinosWrappers
{
  class SparseMatrix;
  class Vector;
  class BlockSparseMatrix;
  class BlockVector;
  namespace MPI
  {
    class Vector;
    class BlockVector;
  }
}
#endif


namespace MatrixCreator
{
  template <int dim, typename number, int spacedim>
  void create_mass_matrix (const Mapping<dim, spacedim>       &mapping,
                           const DoFHandler<dim,spacedim>    &dof,
                           const Quadrature<dim>    &q,
                           SparseMatrix<number>     &matrix,
                           const Function<spacedim> *const a = 0,
                           const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, typename number, int spacedim>
  void create_mass_matrix (const DoFHandler<dim,spacedim>    &dof,
                           const Quadrature<dim>    &q,
                           SparseMatrix<number>     &matrix,
                           const Function<spacedim> *const a = 0,
                           const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, typename number, int spacedim>
  void create_mass_matrix (const Mapping<dim, spacedim>   &mapping,
                           const DoFHandler<dim,spacedim> &dof,
                           const Quadrature<dim>    &q,
                           SparseMatrix<number>     &matrix,
                           const Function<spacedim> &rhs,
                           Vector<number>           &rhs_vector,
                           const Function<spacedim> *const a = 0,
                           const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, typename number, int spacedim>
  void create_mass_matrix (const DoFHandler<dim,spacedim> &dof,
                           const Quadrature<dim>    &q,
                           SparseMatrix<number>     &matrix,
                           const Function<spacedim> &rhs,
                           Vector<number>           &rhs_vector,
                           const Function<spacedim> *const a = 0,
                           const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, typename number, int spacedim>
  void create_mass_matrix (const hp::MappingCollection<dim,spacedim>       &mapping,
                           const hp::DoFHandler<dim,spacedim>    &dof,
                           const hp::QCollection<dim>    &q,
                           SparseMatrix<number>     &matrix,
                           const Function<spacedim> *const a = 0,
                           const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, typename number, int spacedim>
  void create_mass_matrix (const hp::DoFHandler<dim,spacedim>    &dof,
                           const hp::QCollection<dim>    &q,
                           SparseMatrix<number>     &matrix,
                           const Function<spacedim> *const a = 0,
                           const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, typename number, int spacedim>
  void create_mass_matrix (const hp::MappingCollection<dim,spacedim> &mapping,
                           const hp::DoFHandler<dim,spacedim> &dof,
                           const hp::QCollection<dim> &q,
                           SparseMatrix<number>     &matrix,
                           const Function<spacedim> &rhs,
                           Vector<number>           &rhs_vector,
                           const Function<spacedim> *const a = 0,
                           const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, typename number, int spacedim>
  void create_mass_matrix (const hp::DoFHandler<dim,spacedim> &dof,
                           const hp::QCollection<dim> &q,
                           SparseMatrix<number>     &matrix,
                           const Function<spacedim> &rhs,
                           Vector<number>           &rhs_vector,
                           const Function<spacedim> *const a = 0,
                           const ConstraintMatrix   &constraints = ConstraintMatrix());


  template <int dim, int spacedim>
  void create_boundary_mass_matrix (const Mapping<dim, spacedim>       &mapping,
                                    const DoFHandler<dim,spacedim>    &dof,
                                    const Quadrature<dim-1>  &q,
                                    SparseMatrix<double>     &matrix,
                                    const typename FunctionMap<spacedim>::type &boundary_functions,
                                    Vector<double>           &rhs_vector,
                                    std::vector<types::global_dof_index> &dof_to_boundary_mapping,
                                    const Function<spacedim> *const weight = 0,
                                    std::vector<unsigned int> component_mapping = std::vector<unsigned int>());


  template <int dim, int spacedim>
  void create_boundary_mass_matrix (const DoFHandler<dim,spacedim>    &dof,
                                    const Quadrature<dim-1>  &q,
                                    SparseMatrix<double>     &matrix,
                                    const typename FunctionMap<spacedim>::type        &boundary_functions,
                                    Vector<double>           &rhs_vector,
                                    std::vector<types::global_dof_index> &dof_to_boundary_mapping,
                                    const Function<spacedim> *const a = 0,
                                    std::vector<unsigned int> component_mapping = std::vector<unsigned int>());

  template <int dim, int spacedim>
  void create_boundary_mass_matrix (const hp::MappingCollection<dim,spacedim>       &mapping,
                                    const hp::DoFHandler<dim,spacedim>    &dof,
                                    const hp::QCollection<dim-1>  &q,
                                    SparseMatrix<double>     &matrix,
                                    const typename FunctionMap<spacedim>::type &boundary_functions,
                                    Vector<double>           &rhs_vector,
                                    std::vector<types::global_dof_index> &dof_to_boundary_mapping,
                                    const Function<spacedim> *const a = 0,
                                    std::vector<unsigned int> component_mapping = std::vector<unsigned int>());

  template <int dim, int spacedim>
  void create_boundary_mass_matrix (const hp::DoFHandler<dim,spacedim>    &dof,
                                    const hp::QCollection<dim-1>  &q,
                                    SparseMatrix<double>     &matrix,
                                    const typename FunctionMap<spacedim>::type        &boundary_functions,
                                    Vector<double>           &rhs_vector,
                                    std::vector<types::global_dof_index> &dof_to_boundary_mapping,
                                    const Function<spacedim> *const a = 0,
                                    std::vector<unsigned int> component_mapping = std::vector<unsigned int>());

  template <int dim, int spacedim>
  void create_laplace_matrix (const Mapping<dim, spacedim>   &mapping,
                              const DoFHandler<dim,spacedim> &dof,
                              const Quadrature<dim>    &q,
                              SparseMatrix<double>     &matrix,
                              const Function<spacedim> *const a = 0,
                              const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, int spacedim>
  void create_laplace_matrix (const DoFHandler<dim,spacedim> &dof,
                              const Quadrature<dim>    &q,
                              SparseMatrix<double>     &matrix,
                              const Function<spacedim> *const a = 0,
                              const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, int spacedim>
  void create_laplace_matrix (const Mapping<dim, spacedim>   &mapping,
                              const DoFHandler<dim,spacedim> &dof,
                              const Quadrature<dim>    &q,
                              SparseMatrix<double>     &matrix,
                              const Function<spacedim> &rhs,
                              Vector<double>           &rhs_vector,
                              const Function<spacedim> *const a = 0,
                              const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, int spacedim>
  void create_laplace_matrix (const DoFHandler<dim,spacedim> &dof,
                              const Quadrature<dim>    &q,
                              SparseMatrix<double>     &matrix,
                              const Function<spacedim> &rhs,
                              Vector<double>           &rhs_vector,
                              const Function<spacedim> *const a = 0,
                              const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, int spacedim>
  void create_laplace_matrix (const hp::MappingCollection<dim,spacedim> &mapping,
                              const hp::DoFHandler<dim,spacedim> &dof,
                              const hp::QCollection<dim>    &q,
                              SparseMatrix<double>     &matrix,
                              const Function<spacedim> *const a = 0,
                              const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, int spacedim>
  void create_laplace_matrix (const hp::DoFHandler<dim,spacedim> &dof,
                              const hp::QCollection<dim>    &q,
                              SparseMatrix<double>     &matrix,
                              const Function<spacedim> *const a = 0,
                              const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, int spacedim>
  void create_laplace_matrix (const hp::MappingCollection<dim,spacedim> &mapping,
                              const hp::DoFHandler<dim,spacedim> &dof,
                              const hp::QCollection<dim>    &q,
                              SparseMatrix<double>     &matrix,
                              const Function<spacedim>      &rhs,
                              Vector<double>           &rhs_vector,
                              const Function<spacedim> *const a = 0,
                              const ConstraintMatrix   &constraints = ConstraintMatrix());

  template <int dim, int spacedim>
  void create_laplace_matrix (const hp::DoFHandler<dim,spacedim> &dof,
                              const hp::QCollection<dim>    &q,
                              SparseMatrix<double>     &matrix,
                              const Function<spacedim>      &rhs,
                              Vector<double>           &rhs_vector,
                              const Function<spacedim> *const a = 0,
                              const ConstraintMatrix   &constraints = ConstraintMatrix());

  DeclExceptionMsg (ExcComponentMismatch,
                    "You are providing either a right hand side function or a "
                    "coefficient with a number of vector components that is "
                    "inconsistent with the rest of the arguments. If you do "
                    "provide a coefficient or right hand side function, then "
                    "it either needs to have as many components as the finite "
                    "element in use, or only a single vector component. In "
                    "the latter case, the same value will be taken for "
                    "each vector component of the finite element.");
}



namespace MatrixTools
{
  using namespace MatrixCreator;

  template <typename number>
  void
  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
                         SparseMatrix<number>  &matrix,
                         Vector<number>        &solution,
                         Vector<number>        &right_hand_side,
                         const bool             eliminate_columns = true);

  template <typename number>
  void
  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
                         BlockSparseMatrix<number>           &matrix,
                         BlockVector<number>                 &solution,
                         BlockVector<number>                 &right_hand_side,
                         const bool           eliminate_columns = true);

#ifdef DEAL_II_WITH_PETSC

  void
  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
                         PETScWrappers::SparseMatrix  &matrix,
                         PETScWrappers::Vector  &solution,
                         PETScWrappers::Vector  &right_hand_side,
                         const bool             eliminate_columns = true);

  void
  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
                         PETScWrappers::MPI::SparseMatrix  &matrix,
                         PETScWrappers::MPI::Vector  &solution,
                         PETScWrappers::MPI::Vector  &right_hand_side,
                         const bool             eliminate_columns = true);

  void
  apply_boundary_values (const std::map<types::global_dof_index,double>  &boundary_values,
                         PETScWrappers::MPI::BlockSparseMatrix &matrix,
                         PETScWrappers::MPI::BlockVector        &solution,
                         PETScWrappers::MPI::BlockVector        &right_hand_side,
                         const bool       eliminate_columns = true);

#endif

#ifdef DEAL_II_WITH_TRILINOS

  void
  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
                         TrilinosWrappers::SparseMatrix  &matrix,
                         TrilinosWrappers::Vector        &solution,
                         TrilinosWrappers::Vector        &right_hand_side,
                         const bool             eliminate_columns = true);

  void
  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
                         TrilinosWrappers::BlockSparseMatrix  &matrix,
                         TrilinosWrappers::BlockVector        &solution,
                         TrilinosWrappers::BlockVector        &right_hand_side,
                         const bool                eliminate_columns = true);

  void
  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
                         TrilinosWrappers::SparseMatrix  &matrix,
                         TrilinosWrappers::MPI::Vector   &solution,
                         TrilinosWrappers::MPI::Vector   &right_hand_side,
                         const bool             eliminate_columns = true);

  void
  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
                         TrilinosWrappers::BlockSparseMatrix  &matrix,
                         TrilinosWrappers::MPI::BlockVector   &solution,
                         TrilinosWrappers::MPI::BlockVector   &right_hand_side,
                         const bool                eliminate_columns = true);
#endif

  void
  local_apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
                               const std::vector<types::global_dof_index> &local_dof_indices,
                               FullMatrix<double> &local_matrix,
                               Vector<double>     &local_rhs,
                               const bool          eliminate_columns);

  DeclExceptionMsg (ExcBlocksDontMatch,
                    "You are providing a matrix whose subdivision into "
                    "blocks in either row or column direction does not use "
                    "the same blocks sizes as the solution vector or "
                    "right hand side vectors, respectively.");
}



DEAL_II_NAMESPACE_CLOSE

#endif