libMesh::SparsityPattern::Build Class Reference

#include <sparsity_pattern.h>

List of all members.

Public Member Functions
	Build (const MeshBase &mesh_in, const DofMap &dof_map_in, const CouplingMatrix *dof_coupling_in, const bool implicit_neighbor_dofs_in, const bool need_full_sparsity_pattern_in)
	Build (Build &other, Threads::split)
void	operator() (const ConstElemRange &range)
void	join (const Build &other)
void	parallel_sync ()
Public Attributes
SparsityPattern::Graph	sparsity_pattern
SparsityPattern::NonlocalGraph	nonlocal_pattern
std::vector< dof_id_type >	n_nz
std::vector< dof_id_type >	n_oz
Private Attributes
const MeshBase &	mesh
const DofMap &	dof_map
const CouplingMatrix *	dof_coupling
const bool	implicit_neighbor_dofs
const bool	need_full_sparsity_pattern

---

Detailed Description

This helper class can be called on multiple threads to compute the sparsity pattern (or graph) of the sparse matrix resulting from the discretization. This pattern may be used directly by a particular sparse matrix format (e.g. LaspackMatrix) or indirectly (e.g. PetscMatrix). In the latter case the number of nonzeros per row of the matrix is needed for efficient preallocation. In this case it suffices to provide estimate (but bounding) values, and in this case the threaded method can take some short-cuts for efficiency.

Definition at line 78 of file sparsity_pattern.h.

---

Constructor & Destructor Documentation

libMesh::SparsityPattern::Build::Build	(	const MeshBase &	mesh_in,
		const DofMap &	dof_map_in,
		const CouplingMatrix *	dof_coupling_in,
		const bool	implicit_neighbor_dofs_in,
		const bool	need_full_sparsity_pattern_in
	)			[inline]

Definition at line 95 of file sparsity_pattern.h.

                                                     :
      mesh(mesh_in),
      dof_map(dof_map_in),
      dof_coupling(dof_coupling_in),
      implicit_neighbor_dofs(implicit_neighbor_dofs_in),
      need_full_sparsity_pattern(need_full_sparsity_pattern_in),
      sparsity_pattern(),
      nonlocal_pattern(),
      n_nz(),
      n_oz()
    {}

libMesh::SparsityPattern::Build::Build	(	Build &	other,
		Threads::split
	)			[inline]

Definition at line 111 of file sparsity_pattern.h.

                                       :
      mesh(other.mesh),
      dof_map(other.dof_map),
      dof_coupling(other.dof_coupling),
      implicit_neighbor_dofs(other.implicit_neighbor_dofs),
      need_full_sparsity_pattern(other.need_full_sparsity_pattern),
      sparsity_pattern(),
      nonlocal_pattern(),
      n_nz(),
      n_oz()
    {}

---

Member Function Documentation

void libMesh::SparsityPattern::Build::join

(

const Build &

other

)

Definition at line 2542 of file dof_map.C.

References dof_map, libMesh::DofMap::end_dof(), libMesh::DofMap::first_dof(), std::min(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_on_processor(), n_nz, n_oz, need_full_sparsity_pattern, nonlocal_pattern, libMesh::processor_id(), libMesh::MeshBase::processor_id(), and sparsity_pattern.

{
  const processor_id_type proc_id           = mesh.processor_id();
  const dof_id_type       n_global_dofs     = dof_map.n_dofs();
  const dof_id_type       n_dofs_on_proc    = dof_map.n_dofs_on_processor(proc_id);
  const dof_id_type       first_dof_on_proc = dof_map.first_dof(proc_id);
  const dof_id_type       end_dof_on_proc   = dof_map.end_dof(proc_id);

  libmesh_assert_equal_to (sparsity_pattern.size(), other.sparsity_pattern.size());
  libmesh_assert_equal_to (n_nz.size(), sparsity_pattern.size());
  libmesh_assert_equal_to (n_oz.size(), sparsity_pattern.size());

  for (dof_id_type r=0; r<n_dofs_on_proc; r++)
    {
      // increment the number of on and off-processor nonzeros in this row
      // (note this will be an upper bound unless we need the full sparsity pattern)
      if (need_full_sparsity_pattern)
        {
          SparsityPattern::Row       &my_row    = sparsity_pattern[r];
          const SparsityPattern::Row &their_row = other.sparsity_pattern[r];

          // simple copy if I have no dofs
          if (my_row.empty())
            my_row = their_row;

          // otherwise add their DOFs to mine, resort, and re-unique the row
          else if (!their_row.empty()) // do nothing for the trivial case where
            {                          // their row is empty
              my_row.insert (my_row.end(),
                             their_row.begin(),
                             their_row.end());

              // We cannot use SparsityPattern::sort_row() here because it expects
              // the [begin,middle) [middle,end) to be non-overlapping.  This is not
              // necessarily the case here, so use std::sort()
              std::sort (my_row.begin(), my_row.end());

              my_row.erase(std::unique (my_row.begin(), my_row.end()), my_row.end());
            }

          // fix the number of on and off-processor nonzeros in this row
          n_nz[r] = n_oz[r] = 0;

          for (std::size_t j=0; j<my_row.size(); j++)
            if ((my_row[j] < first_dof_on_proc) || (my_row[j] >= end_dof_on_proc))
              n_oz[r]++;
            else
              n_nz[r]++;
        }
      else
        {
          n_nz[r] += other.n_nz[r];
          n_nz[r] = std::min(n_nz[r], n_dofs_on_proc);
          n_oz[r] += other.n_oz[r];
          n_oz[r] =std::min(n_oz[r], static_cast<dof_id_type>(n_global_dofs-n_nz[r]));
        }
    }

  // Move nonlocal row information to ourselves; the other thread
  // won't need it in the map after that.
  NonlocalGraph::const_iterator it = other.nonlocal_pattern.begin();
  for (; it != other.nonlocal_pattern.end(); ++it)
    {
      const dof_id_type dof_id = it->first;

#ifndef NDEBUG
      processor_id_type dbg_proc_id = 0;
      while (dof_id >= dof_map.end_dof(dbg_proc_id))
        dbg_proc_id++;
      libmesh_assert (dbg_proc_id != libMesh::processor_id());
#endif

      const SparsityPattern::Row &their_row = it->second;

      // We should have no empty values in a map
      libmesh_assert (!their_row.empty());

      NonlocalGraph::iterator my_it = nonlocal_pattern.find(it->first);
      if (my_it == nonlocal_pattern.end())
        {
//          nonlocal_pattern[it->first].swap(their_row);
          nonlocal_pattern[it->first] = their_row;
        }
      else
        {
          SparsityPattern::Row &my_row = my_it->second;

          my_row.insert (my_row.end(),
                         their_row.begin(),
                         their_row.end());

          // We cannot use SparsityPattern::sort_row() here because it expects
          // the [begin,middle) [middle,end) to be non-overlapping.  This is not
          // necessarily the case here, so use std::sort()
          std::sort (my_row.begin(), my_row.end());

          my_row.erase(std::unique (my_row.begin(), my_row.end()), my_row.end());
        }
    }
}

void libMesh::SparsityPattern::Build::operator()

(

const ConstElemRange &

range

)

Definition at line 2154 of file dof_map.C.

References libMesh::Elem::active_family_tree_by_neighbor(), libMesh::StoredRange< iterator_type, object_type >::begin(), dof_coupling, libMesh::DofMap::dof_indices(), dof_map, libMesh::CouplingMatrix::empty(), libMesh::StoredRange< iterator_type, object_type >::end(), libMesh::DofMap::end_dof(), libMesh::DofMap::find_connected_dofs(), libMesh::DofMap::first_dof(), implicit_neighbor_dofs, libMesh::DofMap::n_dofs_on_processor(), n_nz, n_oz, libMesh::Elem::n_sides(), libMesh::DofMap::n_variables(), need_full_sparsity_pattern, libMesh::Elem::neighbor(), nonlocal_pattern, libMesh::MeshBase::processor_id(), libMesh::CouplingMatrix::size(), libMesh::SparsityPattern::sort_row(), and sparsity_pattern.

{
  // Compute the sparsity structure of the global matrix.  This can be
  // fed into a PetscMatrix to allocate exacly the number of nonzeros
  // necessary to store the matrix.  This algorithm should be linear
  // in the (# of elements)*(# nodes per element)
  const processor_id_type proc_id           = mesh.processor_id();
  const dof_id_type n_dofs_on_proc    = dof_map.n_dofs_on_processor(proc_id);
  const dof_id_type first_dof_on_proc = dof_map.first_dof(proc_id);
  const dof_id_type end_dof_on_proc   = dof_map.end_dof(proc_id);

  sparsity_pattern.resize(n_dofs_on_proc);

  // If the user did not explicitly specify the DOF coupling
  // then all the DOFS are coupled to each other.  Furthermore,
  // we can take a shortcut and do this more quickly here.  So
  // we use an if-test.
  if ((dof_coupling == NULL) || (dof_coupling->empty()))
    {
      std::vector<dof_id_type>
        element_dofs,
        neighbor_dofs,
        dofs_to_add;

      std::vector<const Elem*> active_neighbors;

      for (ConstElemRange::const_iterator elem_it = range.begin() ; elem_it != range.end(); ++elem_it)
        {
          const Elem* const elem = *elem_it;

          // Get the global indices of the DOFs with support on this element
          dof_map.dof_indices (elem, element_dofs);
#ifdef LIBMESH_ENABLE_CONSTRAINTS
          dof_map.find_connected_dofs (element_dofs);
#endif

          // We can be more efficient if we sort the element DOFs
          // into increasing order
          std::sort(element_dofs.begin(), element_dofs.end());

          const unsigned int n_dofs_on_element =
            libmesh_cast_int<unsigned int>(element_dofs.size());

          for (unsigned int i=0; i<n_dofs_on_element; i++)
            {
              const dof_id_type ig = element_dofs[i];

              SparsityPattern::Row *row;

              // We save non-local row components for now so we can
              // communicate them to other processors later.
             
              if ((ig >= first_dof_on_proc) &&
                  (ig <  end_dof_on_proc))
                {
                  // This is what I mean
                  // libmesh_assert_greater_equal ((ig - first_dof_on_proc), 0);
                  // but do the test like this because ig and
                  // first_dof_on_proc are unsigned ints
                  libmesh_assert_greater_equal (ig, first_dof_on_proc);
                  libmesh_assert_less ((ig - first_dof_on_proc), sparsity_pattern.size());

                  row = &sparsity_pattern[ig - first_dof_on_proc];
                }
              else
                {
                  row = &nonlocal_pattern[ig];
                }

              // If the row is empty we will add *all* the element DOFs,
              // so just do that.
              if (row->empty())
                {
                   row->insert(row->end(),
                               element_dofs.begin(),
                               element_dofs.end());
                }
              else
                {
                  // Build a list of the DOF indices not found in the
                  // sparsity pattern
                  dofs_to_add.clear();

                  // Cache iterators.  Low will move forward, subsequent
                  // searches will be on smaller ranges
                  SparsityPattern::Row::iterator
                    low  = std::lower_bound (row->begin(), row->end(), element_dofs.front()),
                    high = std::upper_bound (low,          row->end(), element_dofs.back());

                  for (unsigned int j=0; j<n_dofs_on_element; j++)
                    {
                      const dof_id_type jg = element_dofs[j];

                      // See if jg is in the sorted range
                      std::pair<SparsityPattern::Row::iterator,
                                SparsityPattern::Row::iterator>
                        pos = std::equal_range (low, high, jg);

                      // Must add jg if it wasn't found
                      if (pos.first == pos.second)
                        dofs_to_add.push_back(jg);

                      // pos.first is now a valid lower bound for any
                      // remaining element DOFs. (That's why we sorted them.)
                      // Use it for the next search
                      low = pos.first;
                    }

                  // Add to the sparsity pattern
                  if (!dofs_to_add.empty())
                    {
                      const std::size_t old_size = row->size();

                      row->insert (row->end(),
                                   dofs_to_add.begin(),
                                   dofs_to_add.end());

                      SparsityPattern::sort_row
                        (row->begin(), row->begin()+old_size, row->end());
                    }
                }

              // Now (possibly) add dofs from neighboring elements
              // TODO:[BSK] optimize this like above!
              if (implicit_neighbor_dofs)
                for (unsigned int s=0; s<elem->n_sides(); s++)
                  if (elem->neighbor(s) != NULL)
                    {
                      const Elem* const neighbor_0 = elem->neighbor(s);
#ifdef LIBMESH_ENABLE_AMR
                      neighbor_0->active_family_tree_by_neighbor(active_neighbors,elem);
#else
                      active_neighbors.clear();
                      active_neighbors.push_back(neighbor_0);
#endif

                      for (std::size_t a=0; a != active_neighbors.size(); ++a)
                        {
                          const Elem *neighbor = active_neighbors[a];

                          dof_map.dof_indices (neighbor, neighbor_dofs);
#ifdef LIBMESH_ENABLE_CONSTRAINTS
                          dof_map.find_connected_dofs (neighbor_dofs);
#endif
                          const std::size_t n_dofs_on_neighbor = neighbor_dofs.size();

                          for (std::size_t j=0; j<n_dofs_on_neighbor; j++)
                            {
                              const dof_id_type jg = neighbor_dofs[j];

                              // See if jg is in the sorted range
                              std::pair<SparsityPattern::Row::iterator,
                                        SparsityPattern::Row::iterator>
                                pos = std::equal_range (row->begin(), row->end(), jg);

                              // Insert jg if it wasn't found
                              if (pos.first == pos.second)
                                row->insert (pos.first, jg);
                            }
                        }
                    }
            }
        }
    }

  // This is what we do in the case that the user has specified
  // explicit DOF coupling.
  else
    {
      libmesh_assert(dof_coupling);
      libmesh_assert_equal_to (dof_coupling->size(),
                               dof_map.n_variables());

      const unsigned int n_var = dof_map.n_variables();

      std::vector<dof_id_type>
        element_dofs_i,
        element_dofs_j,
        neighbor_dofs,
        dofs_to_add;


      std::vector<const Elem*> active_neighbors;
      for (ConstElemRange::const_iterator elem_it = range.begin() ; elem_it != range.end(); ++elem_it)
        for (unsigned int vi=0; vi<n_var; vi++)
          {
            const Elem* const elem = *elem_it;

            // Find element dofs for variable vi
            dof_map.dof_indices (elem, element_dofs_i, vi);
#ifdef LIBMESH_ENABLE_CONSTRAINTS
            dof_map.find_connected_dofs (element_dofs_i);
#endif

            // We can be more efficient if we sort the element DOFs
            // into increasing order
            std::sort(element_dofs_i.begin(), element_dofs_i.end());
            const unsigned int n_dofs_on_element_i =
              libmesh_cast_int<unsigned int>(element_dofs_i.size());

            for (unsigned int vj=0; vj<n_var; vj++)
              if ((*dof_coupling)(vi,vj)) // If vi couples to vj
                {
                  // Find element dofs for variable vj, note that
                  // if vi==vj we already have the dofs.
                  if (vi != vj)
                    {
                      dof_map.dof_indices (elem, element_dofs_j, vj);
#ifdef LIBMESH_ENABLE_CONSTRAINTS
                      dof_map.find_connected_dofs (element_dofs_j);
#endif

                      // We can be more efficient if we sort the element DOFs
                      // into increasing order
                      std::sort (element_dofs_j.begin(), element_dofs_j.end());
                    }
                  else
                    element_dofs_j = element_dofs_i;

                  const unsigned int n_dofs_on_element_j =
                    libmesh_cast_int<unsigned int>(element_dofs_j.size());

                  // there might be 0 dofs for the other variable on the same element (when subdomain variables do not overlap) and that's when we do not do anything
                  if (n_dofs_on_element_j > 0)
                  {
                    for (unsigned int i=0; i<n_dofs_on_element_i; i++)
                    {
                      const dof_id_type ig = element_dofs_i[i];

                      SparsityPattern::Row *row;

                      // We save non-local row components for now so we can
                      // communicate them to other processors later.
             
                      if ((ig >= first_dof_on_proc) &&
                          (ig <  end_dof_on_proc))
                        {
                          // This is what I mean
                          // libmesh_assert_greater_equal ((ig - first_dof_on_proc), 0);
                          // but do the test like this because ig and
                          // first_dof_on_proc are unsigned ints
                          libmesh_assert_greater_equal (ig, first_dof_on_proc);
                          libmesh_assert_less (ig, (sparsity_pattern.size() +
                                        first_dof_on_proc));

                          row = &sparsity_pattern[ig - first_dof_on_proc];
                        }
                      else
                        {
                          row = &nonlocal_pattern[ig];
                        }

                      // If the row is empty we will add *all* the element j DOFs,
                      // so just do that.
                      if (row->empty())
                        {
                          row->insert(row->end(),
                                      element_dofs_j.begin(),
                                      element_dofs_j.end());
                        }
                      else
                        {
                          // Build a list of the DOF indices not found in the
                          // sparsity pattern
                          dofs_to_add.clear();

                          // Cache iterators.  Low will move forward, subsequent
                          // searches will be on smaller ranges
                          SparsityPattern::Row::iterator
                            low  = std::lower_bound
                              (row->begin(), row->end(), element_dofs_j.front()),
                            high = std::upper_bound
                              (low,          row->end(), element_dofs_j.back());

                          for (unsigned int j=0; j<n_dofs_on_element_j; j++)
                            {
                              const dof_id_type jg = element_dofs_j[j];

                              // See if jg is in the sorted range
                              std::pair<SparsityPattern::Row::iterator,
                                        SparsityPattern::Row::iterator>
                                pos = std::equal_range (low, high, jg);

                              // Must add jg if it wasn't found
                              if (pos.first == pos.second)
                                dofs_to_add.push_back(jg);

                              // pos.first is now a valid lower bound for any
                              // remaining element j DOFs. (That's why we sorted them.)
                              // Use it for the next search
                              low = pos.first;
                            }

                          // Add to the sparsity pattern
                          if (!dofs_to_add.empty())
                            {
                              const std::size_t old_size = row->size();

                              row->insert (row->end(),
                                           dofs_to_add.begin(),
                                           dofs_to_add.end());

                              SparsityPattern::sort_row
                                (row->begin(), row->begin()+old_size,
                                 row->end());
                            }
                        }
                       // Now (possibly) add dofs from neighboring elements
                       // TODO:[BSK] optimize this like above!
                       if (implicit_neighbor_dofs)
                         for (unsigned int s=0; s<elem->n_sides(); s++)
                           if (elem->neighbor(s) != NULL)
                             {
                               const Elem* const neighbor_0 = elem->neighbor(s);
#ifdef LIBMESH_ENABLE_AMR
                               neighbor_0->active_family_tree_by_neighbor(active_neighbors,elem);
#else
                               active_neighbors.clear();
                               active_neighbors.push_back(neighbor_0);
#endif

                               for (std::size_t a=0; a != active_neighbors.size(); ++a)
                                 {
                                   const Elem *neighbor = active_neighbors[a];

                                   dof_map.dof_indices (neighbor, neighbor_dofs);
#ifdef LIBMESH_ENABLE_CONSTRAINTS
                                   dof_map.find_connected_dofs (neighbor_dofs);
#endif
                                   const unsigned int n_dofs_on_neighbor =
                                     libmesh_cast_int<unsigned int>(neighbor_dofs.size());

                                   for (unsigned int j=0; j<n_dofs_on_neighbor; j++)
                                     {
                                       const dof_id_type jg = neighbor_dofs[j];

                                       // See if jg is in the sorted range
                                       std::pair<SparsityPattern::Row::iterator,
                                                 SparsityPattern::Row::iterator>
                                         pos = std::equal_range (row->begin(), row->end(), jg);

                                       // Insert jg if it wasn't found
                                       if (pos.first == pos.second)
                                         row->insert (pos.first, jg);
                                     }
                                 }
                             }
                    }
                  }
                }
          }
    }

  // Now a new chunk of sparsity structure is built for all of the
  // DOFs connected to our rows of the matrix.

  // If we're building a full sparsity pattern, then we've got
  // complete rows to work with, so we can just count them from
  // scratch.
  if (need_full_sparsity_pattern)
    {
      n_nz.clear();
      n_oz.clear();
    }

  n_nz.resize (n_dofs_on_proc, 0);
  n_oz.resize (n_dofs_on_proc, 0);

  for (dof_id_type i=0; i<n_dofs_on_proc; i++)
    {
      // Get the row of the sparsity pattern
      SparsityPattern::Row &row = sparsity_pattern[i];

      for (dof_id_type j=0; j<row.size(); j++)
        if ((row[j] < first_dof_on_proc) || (row[j] >= end_dof_on_proc))
          n_oz[i]++;
        else
          n_nz[i]++;

      // If we're not building a full sparsity pattern, then we want
      // to avoid overcounting these entries as much as possible.
      if (!need_full_sparsity_pattern)
        row.clear();
    }
}

void libMesh::SparsityPattern::Build::parallel_sync

(

)

Definition at line 2645 of file dof_map.C.

References libMesh::CommWorld, dof_map, libMesh::DofMap::end_dof(), libMesh::DofMap::first_dof(), std::min(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_on_processor(), n_nz, n_oz, libMesh::n_processors(), need_full_sparsity_pattern, nonlocal_pattern, libMesh::processor_id(), libMesh::Parallel::Communicator::send_receive(), sparsity_pattern, and libMesh::Parallel::Communicator::verify().

{
  parallel_only();
  CommWorld.verify(need_full_sparsity_pattern);

  const dof_id_type n_global_dofs   = dof_map.n_dofs();
  const dof_id_type n_dofs_on_proc  = dof_map.n_dofs_on_processor(libMesh::processor_id());
  const dof_id_type local_first_dof = dof_map.first_dof();
  const dof_id_type local_end_dof   = dof_map.end_dof();

  // Trade sparsity rows with other processors
  for (processor_id_type p=1; p != libMesh::n_processors(); ++p)
    {
      // Push to processor procup while receiving from procdown
      processor_id_type procup = (libMesh::processor_id() + p) %
                                  libMesh::n_processors();
      processor_id_type procdown = (libMesh::n_processors() +
                                    libMesh::processor_id() - p) %
                                    libMesh::n_processors();

      // Pack the sparsity pattern rows to push to procup
      std::vector<dof_id_type> pushed_row_ids,
                               pushed_row_ids_to_me;
      std::vector<std::vector<dof_id_type> > pushed_rows,
                                             pushed_rows_to_me;

      // Move nonlocal row information to a structure to send it from;
      // we don't need it in the map after that.
      NonlocalGraph::iterator it = nonlocal_pattern.begin();
      while (it != nonlocal_pattern.end())
        {
          const dof_id_type dof_id = it->first;
          processor_id_type proc_id = 0;
          while (dof_id >= dof_map.end_dof(proc_id))
            proc_id++;

          libmesh_assert (proc_id != libMesh::processor_id());

          if (proc_id == procup)
            {
              pushed_row_ids.push_back(dof_id);

              // We can't just do the swap trick here, thanks to the
              // differing vector allocators?
              pushed_rows.push_back(std::vector<dof_id_type>());
              pushed_rows.back().assign
                (it->second.begin(), it->second.end());

              nonlocal_pattern.erase(it++);
            }
          else
            ++it;
        }

      CommWorld.send_receive(procup, pushed_row_ids,
                             procdown, pushed_row_ids_to_me);
      CommWorld.send_receive(procup, pushed_rows,
                             procdown, pushed_rows_to_me);
      pushed_row_ids.clear();
      pushed_rows.clear();

      const std::size_t n_rows = pushed_row_ids_to_me.size();
      for (std::size_t i=0; i != n_rows; ++i)
        {
          const dof_id_type r = pushed_row_ids_to_me[i];
          const dof_id_type my_r = r - local_first_dof;

          std::vector<dof_id_type> &their_row = pushed_rows_to_me[i];
        
          if (need_full_sparsity_pattern)
            {
              SparsityPattern::Row &my_row =
                sparsity_pattern[my_r];

              // They wouldn't have sent an empty row
              libmesh_assert(!their_row.empty());

              // We can end up with an empty row on a dof that touches our
              // inactive elements but not our active ones
              if (my_row.empty())
                {
                  my_row.assign (their_row.begin(),
                                 their_row.end());
                }
              else
                {
                  my_row.insert (my_row.end(),
                                 their_row.begin(),
                                 their_row.end());

                  // We cannot use SparsityPattern::sort_row() here because it expects
                  // the [begin,middle) [middle,end) to be non-overlapping.  This is not
                  // necessarily the case here, so use std::sort()
                  std::sort (my_row.begin(), my_row.end());

                  my_row.erase(std::unique (my_row.begin(), my_row.end()), my_row.end());
                }

              // fix the number of on and off-processor nonzeros in this row
              n_nz[my_r] = n_oz[my_r] = 0;

              for (std::size_t j=0; j<my_row.size(); j++)
                if ((my_row[j] < local_first_dof) || (my_row[j] >= local_end_dof))
                  n_oz[my_r]++;
                else
                  n_nz[my_r]++;
            }
          else
            {
              for (std::size_t j=0; j<their_row.size(); j++)
                if ((their_row[j] < local_first_dof) || (their_row[j] >= local_end_dof))
                  n_oz[my_r]++;
                else
                  n_nz[my_r]++;

              n_nz[my_r] = std::min(n_nz[my_r], n_dofs_on_proc);
              n_oz[my_r] = std::min(n_oz[my_r],
                                    static_cast<dof_id_type>(n_global_dofs-n_nz[my_r]));
            }
        }
    }

    // We should have sent everything at this point.
    libmesh_assert (nonlocal_pattern.empty());
}

---

Member Data Documentation

const CouplingMatrix* libMesh::SparsityPattern::Build::dof_coupling [private]

Definition at line 83 of file sparsity_pattern.h.

Referenced by operator()().

const DofMap& libMesh::SparsityPattern::Build::dof_map [private]

Definition at line 82 of file sparsity_pattern.h.

Referenced by join(), operator()(), and parallel_sync().

const bool libMesh::SparsityPattern::Build::implicit_neighbor_dofs [private]

Definition at line 84 of file sparsity_pattern.h.

Referenced by operator()().

const MeshBase& libMesh::SparsityPattern::Build::mesh [private]

Definition at line 81 of file sparsity_pattern.h.

std::vector<dof_id_type> libMesh::SparsityPattern::Build::n_nz

Definition at line 92 of file sparsity_pattern.h.

Referenced by join(), operator()(), and parallel_sync().

std::vector<dof_id_type> libMesh::SparsityPattern::Build::n_oz

Definition at line 93 of file sparsity_pattern.h.

Referenced by join(), operator()(), and parallel_sync().

const bool libMesh::SparsityPattern::Build::need_full_sparsity_pattern [private]

Definition at line 85 of file sparsity_pattern.h.

Referenced by join(), operator()(), and parallel_sync().

SparsityPattern::NonlocalGraph libMesh::SparsityPattern::Build::nonlocal_pattern

Definition at line 90 of file sparsity_pattern.h.

Referenced by join(), operator()(), and parallel_sync().

SparsityPattern::Graph libMesh::SparsityPattern::Build::sparsity_pattern

Definition at line 89 of file sparsity_pattern.h.

Referenced by join(), operator()(), and parallel_sync().

---

The documentation for this class was generated from the following files:

• sparsity_pattern.h
• dof_map.C