libMesh::SparsityPattern::Build类 参考

This helper class can be called on multiple threads to compute the sparsity pattern (or graph) of the sparse matrix resulting from the discretization. 更多...

#include <sparsity_pattern.h>

类 libMesh::SparsityPattern::Build 继承关系图:

Public 成员函数
	Build (const DofMap &dof_map_in, const CouplingMatrix *dof_coupling_in, const std::set< GhostingFunctor * > &coupling_functors_in, const bool implicit_neighbor_dofs_in, const bool need_full_sparsity_pattern_in, const bool calculate_constrained_in=false)
	Build (const Build &)=default
	Special functions. 更多...
Build &	operator= (const Build &)=delete
	Build (Build &&)=default
Build &	operator= (Build &&)=delete
	~Build ()=default
	Build (Build &other, Threads::split)
	Splitting constructor, for use in multithreaded loops. 更多...
void	operator() (const ConstElemRange &range)
	Add entries from a range of elements to this object's sparsity pattern. 更多...
void	join (const Build &other)
	Combine the sparsity pattern in other with this object's sparsity pattern. 更多...
void	parallel_sync ()
	Send sparsity pattern data relevant to other processors to those processors, and receive and incorporate data relevant to us. 更多...
const SparsityPattern::Graph &	get_sparsity_pattern () const
	Rows of sparse matrix indices, indexed by the offset from the first DoF on this processor. 更多...
const SparsityPattern::NonlocalGraph &	get_nonlocal_pattern () const
	Rows of sparse matrix indices, mapped from global DoF number, which belong on other processors. 更多...
const std::vector< dof_id_type > &	get_n_nz () const
	The number of on-processor nonzeros in my portion of the global matrix. 更多...
const std::vector< dof_id_type > &	get_n_oz () const
	The number of off-processor nonzeros in my portion of the global matrix. 更多...
void	apply_extra_sparsity_object (SparsityPattern::AugmentSparsityPattern &asp)
	Let a user-provided AugmentSparsityPattern subclass modify our sparsity structure. 更多...
void	apply_extra_sparsity_function (void(*func)(SparsityPattern::Graph &sparsity, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz, void *context), void *context)
	Let a user-provided function modify our sparsity structure. 更多...
void	clear_full_sparsity ()
	Clear the "full" details of our sparsity structure, leaving only the counts of non-zero entries. 更多...

Private 成员函数
void	handle_vi_vj (const std::vector< dof_id_type > &element_dofs_i, const std::vector< dof_id_type > &element_dofs_j)
void	sorted_connected_dofs (const Elem *elem, std::vector< dof_id_type > &dofs_vi, unsigned int vi)

Private 属性
const DofMap &	dof_map
const CouplingMatrix *	dof_coupling
const std::set < GhostingFunctor * > &	coupling_functors
const bool	implicit_neighbor_dofs
const bool	need_full_sparsity_pattern
const bool	calculate_constrained
std::unordered_set< dof_id_type >	hashed_dof_sets
SparsityPattern::Graph	sparsity_pattern
SparsityPattern::NonlocalGraph	nonlocal_pattern
std::vector< dof_id_type >	n_nz
std::vector< dof_id_type >	n_oz

详细描述

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.

在文件 sparsity_pattern.h 第 102 行定义.

构造及析构函数说明

libMesh::SparsityPattern::Build::Build	(	const DofMap &	dof_map_in,
		const CouplingMatrix *	dof_coupling_in,
		const std::set< GhostingFunctor * > &	coupling_functors_in,
		const bool	implicit_neighbor_dofs_in,
		const bool	need_full_sparsity_pattern_in,
		const bool	calculate_constrained_in = false
	)

在文件 sparsity_pattern.C 第 46 行定义.

                                                   :
  ParallelObject(dof_map_in),
  dof_map(dof_map_in),
  dof_coupling(dof_coupling_in),
  coupling_functors(coupling_functors_in),
  implicit_neighbor_dofs(implicit_neighbor_dofs_in),
  need_full_sparsity_pattern(need_full_sparsity_pattern_in),
  calculate_constrained(calculate_constrained_in),
  sparsity_pattern(),
  nonlocal_pattern(),
  n_nz(),
  n_oz()
{}

libMesh::SparsityPattern::Build::Build ( const Build &  )

default

Special functions.

• The Build object holds references to DofMap and coupling functors, therefore it can't be assigned.

libMesh::SparsityPattern::Build::Build ( Build &&  )

default

libMesh::SparsityPattern::Build::~Build ( )

default

libMesh::SparsityPattern::Build::Build	(	Build &	other,
		Threads::split
	)

Splitting constructor, for use in multithreaded loops.

在文件 sparsity_pattern.C 第 67 行定义.

                                         :
  ParallelObject(other),
  dof_map(other.dof_map),
  dof_coupling(other.dof_coupling),
  coupling_functors(other.coupling_functors),
  implicit_neighbor_dofs(other.implicit_neighbor_dofs),
  need_full_sparsity_pattern(other.need_full_sparsity_pattern),
  calculate_constrained(other.calculate_constrained),
  hashed_dof_sets(other.hashed_dof_sets),
  sparsity_pattern(),
  nonlocal_pattern(),
  n_nz(),
  n_oz()
{}

成员函数说明

void libMesh::SparsityPattern::Build::apply_extra_sparsity_function ( void(*)(SparsityPattern::Graph &sparsity, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz, void *context)  func, void *  context  )

inline

Let a user-provided function modify our sparsity structure.

在文件 sparsity_pattern.h 第 184 行定义.

参考 sparsity_pattern.

  { func(sparsity_pattern, n_nz, n_oz, context); }

void libMesh::SparsityPattern::Build::apply_extra_sparsity_object

(

SparsityPattern::AugmentSparsityPattern &

asp

)

Let a user-provided AugmentSparsityPattern subclass modify our sparsity structure.

在文件 sparsity_pattern.C 第 602 行定义.

参考 libMesh::SparsityPattern::AugmentSparsityPattern::augment_sparsity_pattern(), n_nz, n_oz , 以及 sparsity_pattern.

{
  asp.augment_sparsity_pattern (sparsity_pattern, n_nz, n_oz);
}

void libMesh::SparsityPattern::Build::clear_full_sparsity ( )

inline

Clear the "full" details of our sparsity structure, leaving only the counts of non-zero entries.

在文件 sparsity_pattern.h 第 195 行定义.

参考 nonlocal_pattern , 以及 sparsity_pattern.

  {
    sparsity_pattern.clear();
    nonlocal_pattern.clear();
  }

const std::vector<dof_id_type>& libMesh::SparsityPattern::Build::get_n_nz ( ) const

inline

The number of on-processor nonzeros in my portion of the global matrix.

在文件 sparsity_pattern.h 第 165 行定义.

参考 n_nz.

  { return n_nz; }

const std::vector<dof_id_type>& libMesh::SparsityPattern::Build::get_n_oz ( ) const

inline

The number of off-processor nonzeros in my portion of the global matrix.

在文件 sparsity_pattern.h 第 172 行定义.

参考 n_oz.

  { return n_oz; }

const SparsityPattern::NonlocalGraph& libMesh::SparsityPattern::Build::get_nonlocal_pattern ( ) const

inline

Rows of sparse matrix indices, mapped from global DoF number, which belong on other processors.

Stored here only temporarily until a parallel_sync() sends them where they belong.

在文件 sparsity_pattern.h 第 158 行定义.

参考 nonlocal_pattern.

  { return nonlocal_pattern; }

const SparsityPattern::Graph& libMesh::SparsityPattern::Build::get_sparsity_pattern ( ) const

inline

Rows of sparse matrix indices, indexed by the offset from the first DoF on this processor.

在文件 sparsity_pattern.h 第 150 行定义.

参考 sparsity_pattern.

  { return sparsity_pattern; }

void libMesh::SparsityPattern::Build::handle_vi_vj ( const std::vector< dof_id_type > &  element_dofs_i, const std::vector< dof_id_type > &  element_dofs_j  )

private

在文件 sparsity_pattern.C 第 111 行定义.

参考 dof_map, libMesh::DofMap::end_dof(), libMesh::DofMap::first_dof(), hashed_dof_sets, nonlocal_pattern, libMesh::SparsityPattern::sort_row() , 以及 sparsity_pattern.

参考自 operator()().

{
  const unsigned int n_dofs_on_element_i =
    cast_int<unsigned int>(element_dofs_i.size());

  const processor_id_type proc_id     = dof_map.processor_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);

  std::vector<dof_id_type>
    dofs_to_add;

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

  // It only makes sense to compute hashes and see if we can skip
  // doing work when there are a "large" amount of DOFs for a given
  // element. The cutoff for "large" is somewhat arbitrarily chosen
  // based on a test case with a spider node that resulted in O(10^3)
  // entries in element_dofs_i for O(10^3) elements. Making this
  // number larger will disable the hashing optimization in more
  // cases.
  bool dofs_seen = false;
  if (n_dofs_on_element_j > 0 && n_dofs_on_element_i > 256)
    {
      auto hash_i = Utility::hashword(element_dofs_i);
      auto hash_j = Utility::hashword(element_dofs_j);
      auto final_hash = Utility::hashword2(hash_i, hash_j);
      auto result = hashed_dof_sets.insert(final_hash);
      // if insert failed, we have already seen these dofs
      dofs_seen = !result.second;
    }

  // 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 && !dofs_seen)
    {
      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());
                }
            }
        } // End dofs-of-var-i loop
    } // End if-dofs-of-var-j
}

void libMesh::SparsityPattern::Build::join

(

const Build &

other

)

Combine the sparsity pattern in other with this object's sparsity pattern.

Useful in multithreaded loops.

在文件 sparsity_pattern.C 第 363 行定义.

参考 dof_map, libMesh::DofMap::end_dof(), libMesh::DofMap::first_dof(), hashed_dof_sets, libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_on_processor(), n_nz, n_oz, need_full_sparsity_pattern, nonlocal_pattern , 以及 sparsity_pattern.

{
  const processor_id_type proc_id           = dof_map.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 (const auto & df : my_row)
            if ((df < first_dof_on_proc) || (df >= 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.
  for (const auto & p : other.nonlocal_pattern)
    {
#ifndef NDEBUG
      const dof_id_type dof_id = p.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 = p.second;

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

      NonlocalGraph::iterator my_it = nonlocal_pattern.find(p.first);
      if (my_it == nonlocal_pattern.end())
        {
          //          nonlocal_pattern[it->first].swap(their_row);
          nonlocal_pattern[p.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());
        }
    }

  // Combine the other thread's hashed_dof_sets with ours.
  hashed_dof_sets.insert(other.hashed_dof_sets.begin(),
                         other.hashed_dof_sets.end());
}

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

(

const ConstElemRange &

range

)

Add entries from a range of elements to this object's sparsity pattern.

在文件 sparsity_pattern.C 第 238 行定义.

参考 libMesh::DofMap::coupling_functors_begin(), libMesh::DofMap::coupling_functors_end(), dof_map, libMesh::DofMap::end_dof(), libMesh::DofMap::first_dof(), handle_vi_vj(), libMesh::DofObject::invalid_processor_id, libMesh::DofMap::merge_ghost_functor_outputs(), libMesh::DofMap::n_dofs_on_processor(), n_nz, n_oz, libMesh::DofMap::n_variables(), need_full_sparsity_pattern, sorted_connected_dofs() , 以及 sparsity_pattern.

{
  // Compute the sparsity structure of the global matrix.  This can be
  // fed into a PetscMatrix to allocate exactly 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     = dof_map.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);

  // Handle dof coupling specified by library and user coupling functors
  {
    const unsigned int n_var = dof_map.n_variables();

    std::vector<std::vector<dof_id_type> > element_dofs_i(n_var);

    std::vector<const Elem *> coupled_neighbors;
    for (const auto & elem : range)
      {
        // Make some fake element iterators defining a range
        // pointing to only this element.
        Elem * const * elempp = const_cast<Elem * const *>(&elem);
        Elem * const * elemend = elempp+1;

        const MeshBase::const_element_iterator fake_elem_it =
          MeshBase::const_element_iterator(elempp,
                                           elemend,
                                           Predicates::NotNull<Elem * const *>());

        const MeshBase::const_element_iterator fake_elem_end =
          MeshBase::const_element_iterator(elemend,
                                           elemend,
                                           Predicates::NotNull<Elem * const *>());

        GhostingFunctor::map_type elements_to_couple;
        DofMap::CouplingMatricesSet temporary_coupling_matrices;

        dof_map.merge_ghost_functor_outputs(elements_to_couple,
                                            temporary_coupling_matrices,
                                            dof_map.coupling_functors_begin(),
                                            dof_map.coupling_functors_end(),
                                            fake_elem_it,
                                            fake_elem_end,
                                            DofObject::invalid_processor_id);
        for (unsigned int vi=0; vi<n_var; vi++)
          this->sorted_connected_dofs(elem, element_dofs_i[vi], vi);

        for (unsigned int vi=0; vi<n_var; vi++)
          for (const auto & [partner, ghost_coupling] : elements_to_couple)
            {
              // Loop over coupling matrix row variables if we have a
              // coupling matrix, or all variables if not.
              if (ghost_coupling)
                {
                  libmesh_assert_equal_to (ghost_coupling->size(), n_var);
                  ConstCouplingRow ccr(vi, *ghost_coupling);

                  for (const auto & idx : ccr)
                    {
                      if (partner == elem)
                        this->handle_vi_vj(element_dofs_i[vi], element_dofs_i[idx]);
                      else
                        {
                          std::vector<dof_id_type> partner_dofs;
                          this->sorted_connected_dofs(partner, partner_dofs, idx);
                          this->handle_vi_vj(element_dofs_i[vi], partner_dofs);
                        }
                    }
                }
              else
                {
                  for (unsigned int vj = 0; vj != n_var; ++vj)
                    {
                      if (partner == elem)
                        this->handle_vi_vj(element_dofs_i[vi], element_dofs_i[vj]);
                      else
                        {
                          std::vector<dof_id_type> partner_dofs;
                          this->sorted_connected_dofs(partner, partner_dofs, vj);
                          this->handle_vi_vj(element_dofs_i[vi], partner_dofs);
                        }
                    }
                }
            } // End ghosted element loop
      } // End range element loop
  } // End ghosting functor section

  // 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 (const auto & df : row)
        if ((df < first_dof_on_proc) || (df >= 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();
    }
}

Build& libMesh::SparsityPattern::Build::operator= ( const Build &  )

delete

Build& libMesh::SparsityPattern::Build::operator= ( Build &&  )

delete

void libMesh::SparsityPattern::Build::parallel_sync

(

)

Send sparsity pattern data relevant to other processors to those processors, and receive and incorporate data relevant to us.

在文件 sparsity_pattern.C 第 469 行定义.

参考 dof_map, libMesh::DofMap::end_dof(), libMesh::DofMap::first_dof(), libMesh::DofMap::local_index(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_on_processor(), n_nz, n_oz, need_full_sparsity_pattern, nonlocal_pattern , 以及 sparsity_pattern.

{
  parallel_object_only();
  libmesh_assert(this->comm().verify(need_full_sparsity_pattern));

  auto & comm = this->comm();
  auto my_pid = comm.rank();

  const auto n_global_dofs   = dof_map.n_dofs();
  const auto n_dofs_on_proc  = dof_map.n_dofs_on_processor(my_pid);
  const auto local_first_dof = dof_map.first_dof();
  const auto local_end_dof   = dof_map.end_dof();

  // The data to send
  std::map<processor_id_type, std::vector<dof_id_type>> ids_to_send;
  std::map<processor_id_type, std::vector<Row>> rows_to_send;

  // Loop over the nonlocal rows and transform them into the new datastructure
  NonlocalGraph::iterator it = nonlocal_pattern.begin();
  while (it != nonlocal_pattern.end())
  {
    const auto dof_id = it->first;
    auto & row = it->second;

    processor_id_type proc_id = 0;
    while (dof_id >= dof_map.end_dof(proc_id))
      proc_id++;

    ids_to_send[proc_id].push_back(dof_id);

    // Note this invalidates the data in nonlocal_pattern
    rows_to_send[proc_id].push_back(std::move(row));

    // Might as well remove it since it's invalidated anyway
    it = nonlocal_pattern.erase(it);
  }

  std::map<processor_id_type, std::vector<dof_id_type>> received_ids_map;

  auto ids_action_functor =
    [& received_ids_map]
    (processor_id_type pid,
     const std::vector<dof_id_type> & received_ids)
    {
      received_ids_map.emplace(pid, received_ids);
    };

  Parallel::push_parallel_vector_data(this->comm(), ids_to_send,
                                      ids_action_functor);

  auto rows_action_functor =
    [this,
     & received_ids_map,
     n_global_dofs,
     n_dofs_on_proc,
     local_first_dof,
     local_end_dof]
    (processor_id_type pid,
     const std::vector<Row> & received_rows)
    {
      const std::vector<dof_id_type> & received_ids = libmesh_map_find(received_ids_map, pid);

      std::size_t n_rows = received_rows.size();
      libmesh_assert_equal_to(n_rows, received_ids.size());

      for (auto i : IntRange<std::size_t>(0, n_rows))
        {
          const auto r = received_ids[i];
          libmesh_assert(dof_map.local_index(r));

          const auto my_r = r - local_first_dof;

          auto & their_row = received_rows[i];

          if (need_full_sparsity_pattern)
            {
              auto & 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 (const auto & df : my_row)
                if ((df < local_first_dof) || (df >= local_end_dof))
                  n_oz[my_r]++;
                else
                  n_nz[my_r]++;
            }
          else
            {
              for (const auto & df : their_row)
                if ((df < local_first_dof) || (df >= 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]));
            }
        }
    };

  Parallel::push_parallel_vector_data(this->comm(), rows_to_send,
                                      rows_action_functor);

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

void libMesh::SparsityPattern::Build::sorted_connected_dofs ( const Elem *  elem, std::vector< dof_id_type > &  dofs_vi, unsigned int  vi  )

private

在文件 sparsity_pattern.C 第 92 行定义.

参考 libMesh::DofMap::dof_indices(), dof_map , 以及 libMesh::DofMap::find_connected_dofs().

参考自 operator()().

{
  dof_map.dof_indices (elem, dofs_vi, vi);
#ifdef LIBMESH_ENABLE_CONSTRAINTS
  dof_map.find_connected_dofs (dofs_vi);
#endif
  // We can be more efficient if we sort the element DOFs into
  // increasing order
  std::sort(dofs_vi.begin(), dofs_vi.end());

  // Handle cases where duplicate nodes are intentionally assigned to
  // a single element.
  dofs_vi.erase(std::unique(dofs_vi.begin(), dofs_vi.end()), dofs_vi.end());
}

类成员变量说明

const bool libMesh::SparsityPattern::Build::calculate_constrained

private

在文件 sparsity_pattern.h 第 207 行定义.

const std::set<GhostingFunctor *>& libMesh::SparsityPattern::Build::coupling_functors

private

在文件 sparsity_pattern.h 第 204 行定义.

const CouplingMatrix* libMesh::SparsityPattern::Build::dof_coupling

private

在文件 sparsity_pattern.h 第 203 行定义.

const DofMap& libMesh::SparsityPattern::Build::dof_map

private

在文件 sparsity_pattern.h 第 202 行定义.

参考自 handle_vi_vj(), join(), operator()(), parallel_sync() , 以及 sorted_connected_dofs().

std::unordered_set<dof_id_type> libMesh::SparsityPattern::Build::hashed_dof_sets

private

在文件 sparsity_pattern.h 第 218 行定义.

参考自 handle_vi_vj() , 以及 join().

const bool libMesh::SparsityPattern::Build::implicit_neighbor_dofs

private

在文件 sparsity_pattern.h 第 205 行定义.

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

private

在文件 sparsity_pattern.h 第 235 行定义.

参考自 apply_extra_sparsity_object(), get_n_nz(), join(), operator()() , 以及 parallel_sync().

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

private

在文件 sparsity_pattern.h 第 237 行定义.

参考自 apply_extra_sparsity_object(), get_n_oz(), join(), operator()() , 以及 parallel_sync().

const bool libMesh::SparsityPattern::Build::need_full_sparsity_pattern

private

在文件 sparsity_pattern.h 第 206 行定义.

参考自 join(), operator()() , 以及 parallel_sync().

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

private

在文件 sparsity_pattern.h 第 233 行定义.

参考自 clear_full_sparsity(), get_nonlocal_pattern(), handle_vi_vj(), join() , 以及 parallel_sync().

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

private

在文件 sparsity_pattern.h 第 231 行定义.

参考自 apply_extra_sparsity_function(), apply_extra_sparsity_object(), clear_full_sparsity(), get_sparsity_pattern(), handle_vi_vj(), join(), operator()() , 以及 parallel_sync().

---

该类的文档由以下文件生成:

• /home/lwz/libmesh/include/base/sparsity_pattern.h
• /home/lwz/libmesh/src/base/sparsity_pattern.C