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 <span>
#include <utility>
#include <vector>
 
namespace dolfinx::common
{
class IndexMap;
}
 
namespace dolfinx::la
{
class SparsityPattern
{
public:
  SparsityPattern(MPI_Comm comm,
                  std::array<std::shared_ptr<const common::IndexMap>, 2> maps,
                  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;

  void insert(std::int32_t row, std::int32_t col);

  void insert(std::span<const std::int32_t> rows,
              std::span<const std::int32_t> cols);

  void insert_diagonal(std::span<const std::int32_t> rows);

  void finalize();

  std::shared_ptr<const common::IndexMap> index_map(int dim) const;

  std::vector<std::int64_t> column_indices() const;

  common::IndexMap column_index_map() const;

  int block_size(int dim) const;

  std::int64_t num_nonzeros() const;

  std::int32_t nnz_diag(std::int32_t row) const;

  std::int32_t nnz_off_diag(std::int32_t row) const;

  std::pair<std::span<const std::int32_t>, std::span<const std::int64_t>>
  graph() const;

  std::span<const std::int32_t> off_diagonal_offsets() const;

  MPI_Comm comm() const;
 
private:
  // MPI communicator
  dolfinx::MPI::Comm _comm;
 
  // Index maps for each dimension
  std::array<std::shared_ptr<const common::IndexMap>, 2> _index_maps;
 
  // Block size
  std::array<int, 2> _bs;
 
  // Non-zero ghost columns in owned rows
  std::vector<std::int64_t> _col_ghosts;
 
  // Owning process of ghost columns in owned rows
  std::vector<std::int32_t> _col_ghost_owners;
 
  // Cache for unassembled entries on owned and unowned (ghost) rows
  std::vector<std::vector<std::int32_t>> _row_cache;
 
  // Sparsity pattern adjacency data (computed once pattern is
  // finalised). _edges holds the edges (connected dofs). The edges for
  // node i are in the range [_offsets[i], _offsets[i + 1]).
  std::vector<std::int32_t> _edges;
  std::vector<std::int64_t> _offsets;
 
  // Start of off-diagonal (unowned columns) on each row (row-wise)
  std::vector<std::int32_t> _off_diagonal_offsets;
};
} // namespace dolfinx::la