SparsityPattern.h

// Copyright (C) 2007-2020 Garth N. Wells
//
// This file is part of DOLFINx (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#include <dolfinx/common/MPI.h>
#include <memory>
#include <utility>
#include <vector>
#include <xtl/xspan.hpp>
 
namespace dolfinx::graph
{
template <typename T>
class AdjacencyList;
}
 
namespace dolfinx::common
{
class IndexMap;
}
 
namespace dolfinx::la
{
 
 
class SparsityPattern
{
 
public:
  SparsityPattern(
      MPI_Comm comm,
      const std::array<std::shared_ptr<const common::IndexMap>, 2>& maps,
      const std::array<int, 2>& bs);
 
  SparsityPattern(
      MPI_Comm comm,
      const std::vector<std::vector<const SparsityPattern*>>& patterns,
      const std::array<
          std::vector<
              std::pair<std::reference_wrapper<const common::IndexMap>, int>>,
          2>& maps,
      const std::array<std::vector<int>, 2>& bs);
 
  SparsityPattern(const SparsityPattern& pattern) = delete;
 
  SparsityPattern(SparsityPattern&& pattern) = default;
 
  ~SparsityPattern() = default;
 
  SparsityPattern& operator=(SparsityPattern&& pattern) = default;
 
  std::shared_ptr<const common::IndexMap> index_map(int dim) const;
 
  std::vector<std::int64_t> column_indices() const;
 
  int block_size(int dim) const;
 
  void insert(const xtl::span<const std::int32_t>& rows,
              const xtl::span<const std::int32_t>& cols);
 
  void insert_diagonal(const std::vector<std::int32_t>& rows);
 
  void assemble();
 
  std::int64_t num_nonzeros() const;
 
  const graph::AdjacencyList<std::int32_t>& diagonal_pattern() const;
 
  const graph::AdjacencyList<std::int32_t>& off_diagonal_pattern() const;
 
  MPI_Comm mpi_comm() const;
 
private:
  // MPI communicator
  dolfinx::MPI::Comm _mpi_comm;
 
  // Index maps for each dimension
  std::array<std::shared_ptr<const common::IndexMap>, 2> _index_maps;
  std::array<int, 2> _bs;
 
  // Non-zero ghost columns in owned rows
  std::vector<std::int64_t> _col_ghosts;
 
  // Caches for unassembled entries on owned and unowned (ghost) rows
  std::vector<std::vector<std::int32_t>> _cache_owned;
  std::vector<std::vector<std::int32_t>> _cache_unowned;
 
  // Sparsity pattern data (computed once pattern is finalised)
  std::shared_ptr<graph::AdjacencyList<std::int32_t>> _diagonal;
  std::shared_ptr<graph::AdjacencyList<std::int32_t>> _off_diagonal;
};
} // namespace dolfinx::la