copy_data.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2019 - 2022 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_meshworker_copy_data_h
#define dealii_meshworker_copy_data_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/ndarray.h>
#include <deal.II/base/types.h>
 
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
 
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
namespace MeshWorker
{
  template <int n_matrices      = 1,
            int n_vectors       = n_matrices,
            int n_dof_indices   = n_matrices,
            typename ScalarType = double>
  struct CopyData
  {
    explicit CopyData() = default;
 
    explicit CopyData(const unsigned int size);
 
    explicit CopyData(
      const ndarray<unsigned int, n_matrices, 2> &   matrix_sizes,
      const std::array<unsigned int, n_vectors> &    vector_sizes,
      const std::array<unsigned int, n_dof_indices> &dof_indices_sizes);
 
    CopyData(const CopyData &other) = default;
 
    CopyData &
    operator=(const CopyData &other) = default;
 
    void
    reinit(const unsigned int size);
 
    void
    reinit(const unsigned int index, const unsigned int size);
 
    void
    reinit(const unsigned int index,
           const unsigned int size_rows,
           const unsigned int size_columns);
 
    std::array<FullMatrix<ScalarType>, n_matrices> matrices;
 
    std::array<Vector<ScalarType>, n_vectors> vectors;
 
    std::array<std::vector<types::global_dof_index>, n_dof_indices>
      local_dof_indices;
  };
 
 
#ifndef DOXYGEN
  //
  // Template definitions
  //
  template <int n_matrices,
            int n_vectors,
            int n_dof_indices,
            typename ScalarType>
  CopyData<n_matrices, n_vectors, n_dof_indices, ScalarType>::CopyData(
    const unsigned int size)
  {
    reinit(size);
  }
 
 
 
  template <int n_matrices,
            int n_vectors,
            int n_dof_indices,
            typename ScalarType>
  CopyData<n_matrices, n_vectors, n_dof_indices, ScalarType>::CopyData(
    const ndarray<unsigned int, n_matrices, 2> &   matrix_sizes,
    const std::array<unsigned int, n_vectors> &    vector_sizes,
    const std::array<unsigned int, n_dof_indices> &dof_indices_sizes)
  {
    for (unsigned int i = 0; i < n_matrices; ++i)
      matrices[i].reinit(matrix_sizes[i++]);
 
    for (unsigned int i = 0; i < n_vectors; ++i)
      vectors[i].reinit(vector_sizes[i++]);
 
    for (unsigned int i = 0; i < n_dof_indices; ++i)
      local_dof_indices[i].resize(dof_indices_sizes[i++]);
  }
 
 
 
  template <int n_matrices,
            int n_vectors,
            int n_dof_indices,
            typename ScalarType>
  void
  CopyData<n_matrices, n_vectors, n_dof_indices, ScalarType>::reinit(
    const unsigned int size)
  {
    for (auto &m : matrices)
      m.reinit({size, size});
    for (auto &v : vectors)
      v.reinit(size);
    for (auto &d : local_dof_indices)
      d.resize(size);
  }
 
 
 
  template <int n_matrices,
            int n_vectors,
            int n_dof_indices,
            typename ScalarType>
  void
  CopyData<n_matrices, n_vectors, n_dof_indices, ScalarType>::reinit(
    const unsigned int index,
    const unsigned int size)
  {
    reinit(index, size, size);
  }
 
 
 
  template <int n_matrices,
            int n_vectors,
            int n_dof_indices,
            typename ScalarType>
  void
  CopyData<n_matrices, n_vectors, n_dof_indices, ScalarType>::reinit(
    const unsigned int index,
    const unsigned int size_rows,
    const unsigned int size_columns)
  {
    // We permit different numbers of matrices, vectors and DoF index vectors.
    // So we have to be a bit permissive here.
    constexpr const int max_index =
      std::max(std::max(n_matrices, n_vectors), n_dof_indices);
    (void)max_index;
    Assert(index < max_index, ExcIndexRange(index, 0, max_index));
 
    if (index < n_matrices)
      matrices[index].reinit({size_rows, size_columns});
 
    if (index < n_vectors)
      vectors[index].reinit(size_columns);
 
    if (index < n_dof_indices)
      local_dof_indices[index].resize(size_columns);
  }
 
#endif // DOXYGEN
} // namespace MeshWorker
 
DEAL_II_NAMESPACE_CLOSE
 
#endif