dof_map.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2014 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner

// This library is free software; you can 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.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



#ifndef LIBMESH_DOF_MAP_H
#define LIBMESH_DOF_MAP_H

// Local Includes -----------------------------------
#include "libmesh/libmesh_common.h"
#include "libmesh/auto_ptr.h"
#include "libmesh/enum_order.h"
#include "libmesh/reference_counted_object.h"
#include "libmesh/libmesh.h" // libMesh::invalid_uint
#include "libmesh/variable.h"
#include "libmesh/threads.h"
#include "libmesh/threads_allocators.h"
#include "libmesh/elem_range.h"
#include "libmesh/sparsity_pattern.h"
#include "libmesh/parallel_object.h"

// C++ Includes   -----------------------------------
#include <algorithm>
#include <cstddef>
#include <iterator>
#include <map>
#include <string>
#include <vector>

namespace libMesh
{

// Forward Declarations
class CouplingMatrix;
class DirichletBoundary;
class DirichletBoundaries;
class DofMap;
class DofObject;
class Elem;
class FEType;
class MeshBase;
class Mesh;
class PeriodicBoundaryBase;
class PeriodicBoundaries;
namespace SparsityPattern { class Build; }
class System;
template <typename T> class DenseVectorBase;
template <typename T> class DenseVector;
template <typename T> class DenseMatrix;
template <typename T> class SparseMatrix;
template <typename T> class NumericVector;



// ------------------------------------------------------------
// Do we need constraints for anything?

#if defined(LIBMESH_ENABLE_AMR) ||              \
  defined(LIBMESH_ENABLE_PERIODIC) ||           \
  defined(LIBMESH_ENABLE_DIRICHLET)
#  define LIBMESH_ENABLE_CONSTRAINTS 1
#endif

// ------------------------------------------------------------
// AMR constraint matrix types

#ifdef LIBMESH_ENABLE_CONSTRAINTS

typedef std::map<dof_id_type, Real,
                 std::less<dof_id_type>,
                 Threads::scalable_allocator<std::pair<const dof_id_type, Real> > > DofConstraintRow;

class DofConstraints : public std::map<dof_id_type,
                                       DofConstraintRow,
                                       std::less<dof_id_type>,
                                       Threads::scalable_allocator<std::pair<const dof_id_type, DofConstraintRow> > >
{
};

class DofConstraintValueMap :
    public std::map<dof_id_type, Number,
                    std::less<dof_id_type>,
                    Threads::scalable_allocator<std::pair<const dof_id_type, Number> > >
{
};

class AdjointDofConstraintValues :
    public std::map<unsigned int, DofConstraintValueMap,
                    std::less<unsigned int>,
                    Threads::scalable_allocator
                    <std::pair<const unsigned int, DofConstraintValueMap> > >
{
};

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS

typedef std::map<const Node *, Real,
                 std::less<const Node *>,
                 Threads::scalable_allocator<std::pair<const Node * const, Real> > > NodeConstraintRow;

class NodeConstraints : public std::map<const Node *,
                                        std::pair<NodeConstraintRow,Point>,
                                        std::less<const Node *>,
                                        Threads::scalable_allocator<std::pair<const Node * const, std::pair<NodeConstraintRow,Point> > > >
{
};
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS

#endif // LIBMESH_ENABLE_CONSTRAINTS



// ------------------------------------------------------------
// DofMap class definition

class DofMap : public ReferenceCountedObject<DofMap>,
               public ParallelObject
{
public:

  explicit
  DofMap(const unsigned int sys_number,
         const ParallelObject &parent_decomp);

  ~DofMap();

  class AugmentSparsityPattern
  {
  public:
    virtual ~AugmentSparsityPattern () {}

    virtual void augment_sparsity_pattern (SparsityPattern::Graph & sparsity,
                                           std::vector<dof_id_type> & n_nz,
                                           std::vector<dof_id_type> & n_oz) = 0;
  };

  class AugmentSendList
  {
  public:
    virtual ~AugmentSendList () {}

    virtual void augment_send_list (std::vector<dof_id_type> & send_list) = 0;
  };

  void attach_matrix (SparseMatrix<Number>& matrix);

  bool is_attached (SparseMatrix<Number>& matrix);

  void distribute_dofs (MeshBase&);

  void compute_sparsity (const MeshBase&);

  void clear_sparsity();

  void attach_extra_sparsity_object (DofMap::AugmentSparsityPattern &asp)
  {
    _augment_sparsity_pattern = &asp;
  }

  void attach_extra_sparsity_function(void (*func)(SparsityPattern::Graph & sparsity,
                                                   std::vector<dof_id_type> & n_nz,
                                                   std::vector<dof_id_type> & n_oz,
                                                   void *),
                                      void * context = NULL)
  { _extra_sparsity_function = func; _extra_sparsity_context = context; }

  void attach_extra_send_list_object (DofMap::AugmentSendList &asl)
  {
    _augment_send_list = &asl;
  }

  void attach_extra_send_list_function(void (*func)(std::vector<dof_id_type> &, void *), void * context = NULL)
  { _extra_send_list_function = func; _extra_send_list_context = context; }

  void prepare_send_list ();

  const std::vector<dof_id_type>& get_send_list() const { return _send_list; }

  const std::vector<dof_id_type>& get_n_nz() const {
    libmesh_assert(_n_nz);
    return *_n_nz;
  }

  const std::vector<dof_id_type>& get_n_oz() const {
    libmesh_assert(_n_oz);
    return *_n_oz;
  }

  // /**
  //  * Add an unknown of order \p order and finite element type
  //  * \p type to the system of equations.
  //  */
  // void add_variable (const Variable &var);

  void add_variable_group (const VariableGroup &var_group);

  const VariableGroup& variable_group (const unsigned int c) const;

  const Variable& variable (const unsigned int c) const;

  Order variable_order (const unsigned int c) const;

  Order variable_group_order (const unsigned int vg) const;

  const FEType& variable_type (const unsigned int c) const;

  const FEType& variable_group_type (const unsigned int vg) const;

  unsigned int n_variable_groups() const
  { return cast_int<unsigned int>(_variable_groups.size()); }

  unsigned int n_variables() const
  { return cast_int<unsigned int>(_variables.size()); }

  bool has_blocked_representation() const
  {
#ifdef LIBMESH_ENABLE_BLOCKED_STORAGE
    return ((this->n_variable_groups() == 1) && (this->n_variables() > 1));
#else
    return false;
#endif
  }

  unsigned int block_size() const
  {
#ifdef LIBMESH_ENABLE_BLOCKED_STORAGE
    return (this->has_blocked_representation() ? this->n_variables() : 1);
#else
    return 1;
#endif
  }

  dof_id_type n_dofs() const { return _n_dfs; }

  dof_id_type n_SCALAR_dofs() const { return _n_SCALAR_dofs; }

  dof_id_type n_local_dofs () const
  { return this->n_dofs_on_processor (this->processor_id()); }

  dof_id_type n_dofs_on_processor(const processor_id_type proc) const {
    libmesh_assert_less (proc, _first_df.size());
    return cast_int<dof_id_type>(_end_df[proc] - _first_df[proc]);
  }

  dof_id_type first_dof(const processor_id_type proc) const
  { libmesh_assert_less (proc, _first_df.size()); return _first_df[proc]; }

  dof_id_type first_dof() const
  { return this->first_dof(this->processor_id()); }

#ifdef LIBMESH_ENABLE_AMR

  dof_id_type first_old_dof(const processor_id_type proc) const
  { libmesh_assert_less (proc, _first_old_df.size()); return _first_old_df[proc]; }

  dof_id_type first_old_dof() const
  { return this->first_old_dof(this->processor_id()); }

#endif //LIBMESH_ENABLE_AMR

  dof_id_type last_dof(const processor_id_type proc) const {
    libmesh_deprecated();
    libmesh_assert_less (proc, _end_df.size());
    return cast_int<dof_id_type>(_end_df[proc] - 1);
  }

  dof_id_type last_dof() const
  { return this->last_dof(this->processor_id()); }

  dof_id_type end_dof(const processor_id_type proc) const
  { libmesh_assert_less (proc, _end_df.size()); return _end_df[proc]; }

  dof_id_type end_dof() const
  { return this->end_dof(this->processor_id()); }

#ifdef LIBMESH_ENABLE_AMR

  dof_id_type end_old_dof(const processor_id_type proc) const
  { libmesh_assert_less (proc, _end_old_df.size()); return _end_old_df[proc]; }

  dof_id_type end_old_dof() const
  { return this->end_old_dof(this->processor_id()); }

#endif //LIBMESH_ENABLE_AMR

  void dof_indices (const Elem* const elem,
                    std::vector<dof_id_type>& di) const;

  void dof_indices (const Elem* const elem,
                    std::vector<dof_id_type>& di,
                    const unsigned int vn) const;

  void SCALAR_dof_indices (std::vector<dof_id_type>& di,
                           const unsigned int vn,
                           const bool old_dofs=false) const;

  bool all_semilocal_indices (const std::vector<dof_id_type>& dof_indices) const;

  void set_implicit_neighbor_dofs(bool implicit_neighbor_dofs);

  bool use_coupled_neighbor_dofs(const MeshBase& mesh) const;

  void extract_local_vector (const NumericVector<Number>& Ug,
                             const std::vector<dof_id_type>& dof_indices,
                             DenseVectorBase<Number>& Ue) const;

  void local_variable_indices(std::vector<dof_id_type>& idx,
                              const MeshBase& mesh,
                              unsigned int var_num) const;

#ifdef LIBMESH_ENABLE_CONSTRAINTS

  //--------------------------------------------------------------------
  // Constraint-specific methods
  dof_id_type n_constrained_dofs() const;

  dof_id_type n_local_constrained_dofs() const;

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS

  dof_id_type n_constrained_nodes() const
  { return cast_int<dof_id_type>(_node_constraints.size()); }
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS

  void create_dof_constraints (const MeshBase&, Real time=0);

  void allgather_recursive_constraints (MeshBase&);

  void scatter_constraints (MeshBase&);

  void process_constraints (MeshBase&);

  void add_constraint_row (const dof_id_type dof_number,
                           const DofConstraintRow& constraint_row,
                           const Number constraint_rhs,
                           const bool forbid_constraint_overwrite);

  void add_adjoint_constraint_row (const unsigned int qoi_index,
                                   const dof_id_type dof_number,
                                   const DofConstraintRow& constraint_row,
                                   const Number constraint_rhs,
                                   const bool forbid_constraint_overwrite);

  void add_constraint_row (const dof_id_type dof_number,
                           const DofConstraintRow& constraint_row,
                           const bool forbid_constraint_overwrite = true)
  { add_constraint_row(dof_number, constraint_row, 0., forbid_constraint_overwrite); }

  DofConstraints::const_iterator constraint_rows_begin() const
  { return _dof_constraints.begin(); }

  DofConstraints::const_iterator constraint_rows_end() const
  { return _dof_constraints.end(); }

  void stash_dof_constraints()
  {
    libmesh_assert(_stashed_dof_constraints.empty());
    _dof_constraints.swap(_stashed_dof_constraints);
  }

  void unstash_dof_constraints()
  {
    libmesh_assert(_dof_constraints.empty());
    _dof_constraints.swap(_stashed_dof_constraints);
  }

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS

  NodeConstraints::const_iterator node_constraint_rows_begin() const
  { return _node_constraints.begin(); }

  NodeConstraints::const_iterator node_constraint_rows_end() const
  { return _node_constraints.end(); }
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS

  bool is_constrained_dof (const dof_id_type dof) const;

  bool has_heterogenous_adjoint_constraints (const unsigned int qoi_num) const;

  Number has_heterogenous_adjoint_constraint (const unsigned int qoi_num,
                                              const dof_id_type dof) const;

  DofConstraintValueMap & get_primal_constraint_values();

  bool is_constrained_node (const Node* node) const;

  void print_dof_constraints(std::ostream& os=libMesh::out,
                             bool print_nonlocal=false) const;

  std::string get_local_constraints(bool print_nonlocal=false) const;


  std::pair<Real, Real> max_constraint_error(const System &system,
                                             NumericVector<Number> *v = NULL) const;

#endif // LIBMESH_ENABLE_CONSTRAINTS

  //--------------------------------------------------------------------
  // Constraint-specific methods
  // Some of these methods are enabled (but inlined away to nothing)
  // when constraints are disabled at configure-time.  This is to
  // increase API compatibility of user code with different library
  // builds.

  void constrain_element_matrix (DenseMatrix<Number>& matrix,
                                 std::vector<dof_id_type>& elem_dofs,
                                 bool asymmetric_constraint_rows = true) const;

  void constrain_element_matrix (DenseMatrix<Number>& matrix,
                                 std::vector<dof_id_type>& row_dofs,
                                 std::vector<dof_id_type>& col_dofs,
                                 bool asymmetric_constraint_rows = true) const;

  void constrain_element_vector (DenseVector<Number>&       rhs,
                                 std::vector<dof_id_type>& dofs,
                                 bool asymmetric_constraint_rows = true) const;

  void constrain_element_matrix_and_vector (DenseMatrix<Number>& matrix,
                                            DenseVector<Number>& rhs,
                                            std::vector<dof_id_type>& elem_dofs,
                                            bool asymmetric_constraint_rows = true) const;

  void heterogenously_constrain_element_matrix_and_vector (DenseMatrix<Number>& matrix,
                                                           DenseVector<Number>& rhs,
                                                           std::vector<dof_id_type>& elem_dofs,
                                                           bool asymmetric_constraint_rows = true,
                                                           int qoi_index = -1) const;

  void heterogenously_constrain_element_vector (const DenseMatrix<Number>& matrix,
                                                DenseVector<Number>& rhs,
                                                std::vector<dof_id_type>& elem_dofs,
                                                bool asymmetric_constraint_rows = true,
                                                int qoi_index = -1) const;



  void constrain_element_dyad_matrix (DenseVector<Number>& v,
                                      DenseVector<Number>& w,
                                      std::vector<dof_id_type>& row_dofs,
                                      bool asymmetric_constraint_rows = true) const;

  void constrain_nothing (std::vector<dof_id_type>& dofs) const;

  void enforce_constraints_exactly (const System &system,
                                    NumericVector<Number> *v = NULL,
                                    bool homogeneous = false) const;

  void enforce_adjoint_constraints_exactly (NumericVector<Number> &v,
                                            unsigned int q) const;



#ifdef LIBMESH_ENABLE_PERIODIC

  //--------------------------------------------------------------------
  // PeriodicBoundary-specific methods

  void add_periodic_boundary (const PeriodicBoundaryBase& periodic_boundary);

  void add_periodic_boundary (const PeriodicBoundaryBase& boundary, const PeriodicBoundaryBase& inverse_boundary);

  bool is_periodic_boundary (const boundary_id_type boundaryid) const;

  PeriodicBoundaries * get_periodic_boundaries()
  {
    return _periodic_boundaries;
  }

#endif // LIBMESH_ENABLE_PERIODIC


#ifdef LIBMESH_ENABLE_DIRICHLET

  //--------------------------------------------------------------------
  // DirichletBoundary-specific methods

  void add_dirichlet_boundary (const DirichletBoundary& dirichlet_boundary);

  void add_adjoint_dirichlet_boundary (const DirichletBoundary& dirichlet_boundary,
                                       unsigned int q);

  void remove_dirichlet_boundary (const DirichletBoundary& dirichlet_boundary);

  void remove_adjoint_dirichlet_boundary (const DirichletBoundary& dirichlet_boundary,
                                          unsigned int q);

  const DirichletBoundaries * get_dirichlet_boundaries() const
  {
    return _dirichlet_boundaries;
  }

  DirichletBoundaries * get_dirichlet_boundaries()
  {
    return _dirichlet_boundaries;
  }

  bool has_adjoint_dirichlet_boundaries(unsigned int q) const;

  const DirichletBoundaries *
  get_adjoint_dirichlet_boundaries(unsigned int q) const;

  DirichletBoundaries *
  get_adjoint_dirichlet_boundaries(unsigned int q);

#endif // LIBMESH_ENABLE_DIRICHLET


#ifdef LIBMESH_ENABLE_AMR

  //--------------------------------------------------------------------
  // AMR-specific methods

  // void augment_send_list_for_projection(const MeshBase &);

  void old_dof_indices (const Elem* const elem,
                        std::vector<dof_id_type>& di,
                        const unsigned int vn = libMesh::invalid_uint) const;
  dof_id_type n_old_dofs() const { return _n_old_dfs; }

  void constrain_p_dofs (unsigned int var,
                         const Elem *elem,
                         unsigned int s,
                         unsigned int p);

#endif // LIBMESH_ENABLE_AMR

  void reinit (MeshBase& mesh);

  void clear ();

  void print_info(std::ostream& os=libMesh::out) const;

  std::string get_info() const;

  CouplingMatrix* _dof_coupling;

  unsigned int sys_number() const;

private:

  void _dof_indices (const Elem* const elem, std::vector<dof_id_type>& di,
                     const unsigned int v,
                     const Node * const * nodes,
                     unsigned int       n_nodes
#ifdef DEBUG
                     ,
                     std::size_t & tot_size
#endif
                     ) const;

  UniquePtr<SparsityPattern::Build> build_sparsity(const MeshBase& mesh) const;

  void invalidate_dofs(MeshBase& mesh) const;

  DofObject* node_ptr(MeshBase& mesh, dof_id_type i) const;

  DofObject* elem_ptr(MeshBase& mesh, dof_id_type i) const;

  typedef DofObject* (DofMap::*dofobject_accessor)
    (MeshBase& mesh, dof_id_type i) const;

  template<typename iterator_type>
  void set_nonlocal_dof_objects(iterator_type objects_begin,
                                iterator_type objects_end,
                                MeshBase &mesh,
                                dofobject_accessor objects);

  void distribute_local_dofs_var_major (dof_id_type& next_free_dof,
                                        MeshBase& mesh);

  void distribute_local_dofs_node_major (dof_id_type& next_free_dof,
                                         MeshBase& mesh);

  void add_neighbors_to_send_list(MeshBase& mesh);

#ifdef LIBMESH_ENABLE_CONSTRAINTS

  void build_constraint_matrix (DenseMatrix<Number>& C,
                                std::vector<dof_id_type>& elem_dofs,
                                const bool called_recursively=false) const;

  void build_constraint_matrix_and_vector (DenseMatrix<Number>& C,
                                           DenseVector<Number>& H,
                                           std::vector<dof_id_type>& elem_dofs,
                                           int qoi_index = -1,
                                           const bool called_recursively=false) const;

  void find_connected_dofs (std::vector<dof_id_type> &elem_dofs) const;

  void find_connected_dof_objects (std::vector<const DofObject *> &objs) const;

  void add_constraints_to_send_list();

#endif // LIBMESH_ENABLE_CONSTRAINTS

  std::vector<Variable> _variables;

  std::vector<VariableGroup> _variable_groups;

  const unsigned int _sys_number;

  std::vector<SparseMatrix<Number>* > _matrices;

  std::vector<dof_id_type> _first_df;

  std::vector<dof_id_type> _end_df;

  std::vector<dof_id_type> _first_scalar_df;

  std::vector<dof_id_type> _send_list;

  AugmentSparsityPattern *_augment_sparsity_pattern;

  void (*_extra_sparsity_function)(SparsityPattern::Graph &,
                                   std::vector<dof_id_type> & n_nz,
                                   std::vector<dof_id_type> & n_oz,
                                   void *);
  void * _extra_sparsity_context;

  AugmentSendList *_augment_send_list;

  void (*_extra_send_list_function)(std::vector<dof_id_type> &, void *);

  void * _extra_send_list_context;

  bool need_full_sparsity_pattern;

  UniquePtr<SparsityPattern::Build> _sp;

  std::vector<dof_id_type>* _n_nz;

  std::vector<dof_id_type>* _n_oz;

  dof_id_type _n_dfs;

  dof_id_type _n_SCALAR_dofs;

#ifdef LIBMESH_ENABLE_AMR

  dof_id_type _n_old_dfs;

  std::vector<dof_id_type> _first_old_df;

  std::vector<dof_id_type> _end_old_df;

  std::vector<dof_id_type> _first_old_scalar_df;

#endif

#ifdef LIBMESH_ENABLE_CONSTRAINTS

  DofConstraints _dof_constraints, _stashed_dof_constraints;

  DofConstraintValueMap      _primal_constraint_values;

  AdjointDofConstraintValues _adjoint_constraint_values;
#endif

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS

  NodeConstraints _node_constraints;
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS


#ifdef LIBMESH_ENABLE_PERIODIC

  PeriodicBoundaries *_periodic_boundaries;
#endif

#ifdef LIBMESH_ENABLE_DIRICHLET

  DirichletBoundaries *_dirichlet_boundaries;

  std::vector<DirichletBoundaries *> _adjoint_dirichlet_boundaries;
#endif

  friend class SparsityPattern::Build;

  bool _implicit_neighbor_dofs_initialized;
  bool _implicit_neighbor_dofs;
};


// ------------------------------------------------------------
// Dof Map inline member functions
inline
unsigned int DofMap::sys_number() const
{
  return _sys_number;
}



inline
const VariableGroup & DofMap::variable_group (const unsigned int g) const
{
  libmesh_assert_less (g, _variable_groups.size());

  return _variable_groups[g];
}



inline
const Variable & DofMap::variable (const unsigned int c) const
{
  libmesh_assert_less (c, _variables.size());

  return _variables[c];
}



inline
Order DofMap::variable_order (const unsigned int c) const
{
  libmesh_assert_less (c, _variables.size());

  return _variables[c].type().order;
}



inline
Order DofMap::variable_group_order (const unsigned int vg) const
{
  libmesh_assert_less (vg, _variable_groups.size());

  return _variable_groups[vg].type().order;
}



inline
const FEType& DofMap::variable_type (const unsigned int c) const
{
  libmesh_assert_less (c, _variables.size());

  return _variables[c].type();
}



inline
const FEType& DofMap::variable_group_type (const unsigned int vg) const
{
  libmesh_assert_less (vg, _variable_groups.size());

  return _variable_groups[vg].type();
}



inline
bool DofMap::is_constrained_node (const Node*
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
                                  node
#endif
                                  ) const
{
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  if (_node_constraints.count(node))
    return true;
#endif

  return false;
}

#ifdef LIBMESH_ENABLE_CONSTRAINTS

inline
bool DofMap::is_constrained_dof (const dof_id_type dof) const
{
  if (_dof_constraints.count(dof))
    return true;

  return false;
}


inline
bool DofMap::has_heterogenous_adjoint_constraints (const unsigned int qoi_num) const
{
  AdjointDofConstraintValues::const_iterator it =
    _adjoint_constraint_values.find(qoi_num);
  if (it == _adjoint_constraint_values.end())
    return false;
  if (it->second.empty())
    return false;

  return true;
}


inline
Number DofMap::has_heterogenous_adjoint_constraint (const unsigned int qoi_num,
                                                    const dof_id_type dof) const
{
  AdjointDofConstraintValues::const_iterator it =
    _adjoint_constraint_values.find(qoi_num);
  if (it != _adjoint_constraint_values.end())
    {
      DofConstraintValueMap::const_iterator rhsit =
        it->second.find(dof);
      if (rhsit == it->second.end())
        return 0;
      else
        return rhsit->second;
    }

  return 0;
}



inline
DofConstraintValueMap & DofMap::get_primal_constraint_values()
{
  return _primal_constraint_values;
}



#else

//--------------------------------------------------------------------
// Constraint-specific methods get inlined into nothing if
// constraints are disabled, so there's no reason for users not to
// use them.

inline void DofMap::constrain_element_matrix (DenseMatrix<Number>&,
                                              std::vector<dof_id_type>&,
                                              bool) const {}

inline void DofMap::constrain_element_matrix (DenseMatrix<Number>&,
                                              std::vector<dof_id_type>&,
                                              std::vector<dof_id_type>&,
                                              bool) const {}

inline void DofMap::constrain_element_vector (DenseVector<Number>&,
                                              std::vector<dof_id_type>&,
                                              bool) const {}

inline void DofMap::constrain_element_matrix_and_vector (DenseMatrix<Number>&,
                                                         DenseVector<Number>&,
                                                         std::vector<dof_id_type>&,
                                                         bool) const {}

inline void DofMap::constrain_element_dyad_matrix (DenseVector<Number>&,
                                                   DenseVector<Number>&,
                                                   std::vector<dof_id_type>&,
                                                   bool) const {}

inline void DofMap::enforce_constraints_exactly (const System &,
                                                 NumericVector<Number> *,
                                                 bool = false) const {}

inline void DofMap::enforce_adjoint_constraints_exactly (NumericVector<Number> &,
                                                         unsigned int) const {}

#endif // LIBMESH_ENABLE_CONSTRAINTS

} // namespace libMesh

#endif // LIBMESH_DOF_MAP_H