#include <sparsity_pattern.h>

Inheritance diagram for libMesh::SparsityPattern::Build:

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 ()
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
Public Attributes
SparsityPattern::Graph	sparsity_pattern
SparsityPattern::NonlocalGraph	nonlocal_pattern
std::vector< dof_id_type >	n_nz
std::vector< dof_id_type >	n_oz
Protected Attributes
const Parallel::Communicator &	_communicator
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 79 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
	)

Definition at line 35 of file sparsity_pattern.C.

                                                        :
  ParallelObject(dof_map_in),
  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
	)

Definition at line 54 of file sparsity_pattern.C.

                                        :
  ParallelObject(other),
  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

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const [inline, inherited]

Returns:: a reference to the Parallel::Communicator object used by this mesh.

Definition at line 86 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

  { return _communicator; }

void libMesh::SparsityPattern::Build::join ( const Build & other )

Definition at line 2845 of file dof_map.C.

References dof_id, libMesh::libmesh_assert(), std::min(), n_nz, n_oz, nonlocal_pattern, libMesh::processor_id(), libMesh::ParallelObject::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)
    {
#ifndef NDEBUG
      const dof_id_type dof_id = it->first;

      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 != this->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());
        }
    }
}

processor_id_type libMesh::ParallelObject::n_processors ( ) const [inline, inherited]

Returns:: the number of processors in the group.

Definition at line 92 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::size().

  { return cast_int<processor_id_type>(_communicator.size()); }

void libMesh::SparsityPattern::Build::operator() ( const ConstElemRange & range )

Definition at line 2457 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::libmesh_assert(), 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::ParallelObject::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 =
            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 =
              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 =
                    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 =
                                        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 2948 of file dof_map.C.

References dof_id, libMesh::libmesh_assert(), std::min(), libMesh::n_processors(), and libMesh::processor_id().

{
  parallel_object_only();
  this->comm().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(this->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 != this->n_processors(); ++p)
    {
      // Push to processor procup while receiving from procdown
      processor_id_type procup =
        cast_int<processor_id_type>((this->processor_id() + p) %
                                    this->n_processors());
      processor_id_type procdown =
        cast_int<processor_id_type>((this->n_processors() + this->processor_id() - p) %
                                    this->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 != this->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;
        }

      this->comm().send_receive(procup, pushed_row_ids,
                                procdown, pushed_row_ids_to_me);
      this->comm().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());
}

processor_id_type libMesh::ParallelObject::processor_id ( ) const [inline, inherited]

Returns:: the rank of this processor in the group.

Definition at line 98 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

  { return cast_int<processor_id_type>(_communicator.rank()); }

Member Data Documentation

const Parallel::Communicator& libMesh::ParallelObject::_communicator [protected, inherited]

Definition at line 104 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_solution_vector(), libMesh::ParallelObject::comm(), libMesh::EquationSystems::get_solution(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

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

Definition at line 84 of file sparsity_pattern.h.

Referenced by operator()().

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

Definition at line 83 of file sparsity_pattern.h.

Referenced by operator()().

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

Definition at line 85 of file sparsity_pattern.h.

Referenced by operator()().

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

Definition at line 82 of file sparsity_pattern.h.

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

Definition at line 93 of file sparsity_pattern.h.

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

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

Definition at line 94 of file sparsity_pattern.h.

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

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

Definition at line 86 of file sparsity_pattern.h.

Referenced by operator()().

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

Definition at line 91 of file sparsity_pattern.h.

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

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

Definition at line 90 of file sparsity_pattern.h.

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

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

Public Member Functions

Public Attributes

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation