16 #include <deal.II/lac/trilinos_index_access.h> 17 #include <deal.II/lac/trilinos_sparsity_pattern.h> 19 #ifdef DEAL_II_WITH_TRILINOS 21 # include <deal.II/base/mpi.h> 22 # include <deal.II/base/utilities.h> 24 # include <deal.II/lac/dynamic_sparsity_pattern.h> 25 # include <deal.II/lac/sparsity_pattern.h> 26 # include <deal.II/lac/trilinos_index_access.h> 28 # include <Epetra_Export.h> 30 DEAL_II_NAMESPACE_OPEN
59 (TrilinosWrappers::types::int_type)this->
a_row,
62 (TrilinosWrappers::types::int_type *)&(*
colnum_cache)[0]);
64 AssertThrow(
static_cast<std::vector<size_type>::size_type
>(ncols) ==
86 std_cxx14::make_unique<Epetra_Map>(TrilinosWrappers::types::int_type(0),
87 TrilinosWrappers::types::int_type(0),
89 graph = std_cxx14::make_unique<Epetra_FECrsGraph>(View,
93 graph->FillComplete();
100 reinit(input_map, input_map, n_entries_per_row);
106 const Epetra_Map & input_map,
107 const std::vector<size_type> &n_entries_per_row)
109 reinit(input_map, input_map, n_entries_per_row);
115 const Epetra_Map &input_col_map,
118 reinit(input_row_map, input_col_map, n_entries_per_row);
124 const Epetra_Map & input_row_map,
125 const Epetra_Map & input_col_map,
126 const std::vector<size_type> &n_entries_per_row)
128 reinit(input_row_map, input_col_map, n_entries_per_row);
137 reinit(m, n, n_entries_per_row);
145 const std::vector<size_type> &n_entries_per_row)
147 reinit(m, n, n_entries_per_row);
154 , column_space_map(
std::move(other.column_space_map))
155 , graph(
std::move(other.graph))
156 , nonlocal_graph(
std::move(other.nonlocal_graph))
169 new Epetra_FECrsGraph(View, *column_space_map, *column_space_map, 0))
171 (void)input_sparsity;
174 "Copy constructor only works for empty sparsity patterns."));
180 const MPI_Comm &communicator,
183 reinit(parallel_partitioning,
184 parallel_partitioning,
192 const IndexSet & parallel_partitioning,
193 const MPI_Comm & communicator,
194 const std::vector<size_type> &n_entries_per_row)
196 reinit(parallel_partitioning,
197 parallel_partitioning,
205 const IndexSet &col_parallel_partitioning,
206 const MPI_Comm &communicator,
209 reinit(row_parallel_partitioning,
210 col_parallel_partitioning,
218 const IndexSet & row_parallel_partitioning,
219 const IndexSet & col_parallel_partitioning,
220 const MPI_Comm & communicator,
221 const std::vector<size_type> &n_entries_per_row)
223 reinit(row_parallel_partitioning,
224 col_parallel_partitioning,
232 const IndexSet &col_parallel_partitioning,
234 const MPI_Comm &communicator,
237 reinit(row_parallel_partitioning,
238 col_parallel_partitioning,
241 n_max_entries_per_row);
251 reinit(complete_index_set(m),
252 complete_index_set(n),
262 const std::vector<size_type> &n_entries_per_row)
264 reinit(complete_index_set(m),
265 complete_index_set(n),
277 reinit_sp(
const Epetra_Map & row_map,
278 const Epetra_Map & col_map,
281 std::unique_ptr<Epetra_FECrsGraph> &
graph,
284 Assert(row_map.IsOneToOne(),
285 ExcMessage(
"Row map must be 1-to-1, i.e., no overlap between " 286 "the maps of different processors."));
287 Assert(col_map.IsOneToOne(),
288 ExcMessage(
"Column map must be 1-to-1, i.e., no overlap between " 289 "the maps of different processors."));
291 nonlocal_graph.reset();
293 column_space_map = std_cxx14::make_unique<Epetra_Map>(col_map);
303 if (row_map.Comm().NumProc() > 1)
304 graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
305 Copy, row_map, n_entries_per_row,
false 313 graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
314 Copy, row_map, col_map, n_entries_per_row,
false);
320 reinit_sp(
const Epetra_Map & row_map,
321 const Epetra_Map & col_map,
322 const std::vector<size_type> & n_entries_per_row,
323 std::unique_ptr<Epetra_Map> & column_space_map,
324 std::unique_ptr<Epetra_FECrsGraph> &graph,
325 std::unique_ptr<Epetra_CrsGraph> & nonlocal_graph)
327 Assert(row_map.IsOneToOne(),
328 ExcMessage(
"Row map must be 1-to-1, i.e., no overlap between " 329 "the maps of different processors."));
330 Assert(col_map.IsOneToOne(),
331 ExcMessage(
"Column map must be 1-to-1, i.e., no overlap between " 332 "the maps of different processors."));
335 nonlocal_graph.reset();
341 column_space_map = std_cxx14::make_unique<Epetra_Map>(col_map);
342 std::vector<int> local_entries_per_row(
345 for (
unsigned int i = 0; i < local_entries_per_row.size(); ++i)
346 local_entries_per_row[i] =
349 if (row_map.Comm().NumProc() > 1)
350 graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
351 Copy, row_map, local_entries_per_row.data(),
false 359 graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
360 Copy, row_map, col_map, local_entries_per_row.data(),
false);
365 template <
typename SparsityPatternType>
367 reinit_sp(
const Epetra_Map & row_map,
368 const Epetra_Map & col_map,
369 const SparsityPatternType & sp,
370 const bool exchange_data,
371 std::unique_ptr<Epetra_Map> & column_space_map,
372 std::unique_ptr<Epetra_FECrsGraph> &graph,
373 std::unique_ptr<Epetra_CrsGraph> & nonlocal_graph)
375 nonlocal_graph.reset();
385 column_space_map = std_cxx14::make_unique<Epetra_Map>(col_map);
387 Assert(row_map.LinearMap() ==
true,
389 "This function only works if the row map is contiguous."));
393 std::vector<int> n_entries_per_row(last_row - first_row);
397 for (
size_type row = first_row; row < last_row; ++row)
398 n_entries_per_row[row - first_row] =
399 static_cast<int>(sp.row_length(row));
401 if (row_map.Comm().NumProc() > 1)
402 graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
403 Copy, row_map, n_entries_per_row.data(),
false);
405 graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
406 Copy, row_map, col_map, n_entries_per_row.data(),
false);
411 std::vector<TrilinosWrappers::types::int_type> row_indices;
415 if (exchange_data ==
false)
416 for (
size_type row = first_row; row < last_row; ++row)
418 const TrilinosWrappers::types::int_type
row_length =
423 row_indices.resize(row_length, -1);
425 typename SparsityPatternType::iterator p = sp.begin(row);
430 row_indices[col++] = p->column();
431 if (col < row_length)
435 graph->Epetra_CrsGraph::InsertGlobalIndices(row,
440 for (
size_type row = 0; row < sp.n_rows(); ++row)
442 const TrilinosWrappers::types::int_type
row_length =
447 row_indices.resize(row_length, -1);
449 typename SparsityPatternType::iterator p = sp.begin(row);
454 row_indices[col++] = p->column();
455 if (col < row_length)
459 graph->InsertGlobalIndices(
461 reinterpret_cast<TrilinosWrappers::types::int_type *>(&row),
466 int ierr = graph->GlobalAssemble(*column_space_map,
467 static_cast<const Epetra_Map &>(
472 ierr = graph->OptimizeStorage();
494 const Epetra_Map &input_col_map,
497 reinit_sp(input_row_map,
509 const std::vector<size_type> &n_entries_per_row)
523 const Epetra_Map & input_col_map,
524 const std::vector<size_type> &n_entries_per_row)
526 reinit_sp(input_row_map,
538 const MPI_Comm &communicator,
551 const MPI_Comm & communicator,
552 const std::vector<size_type> &n_entries_per_row)
564 const IndexSet &col_parallel_partitioning,
565 const MPI_Comm &communicator,
584 const IndexSet &col_parallel_partitioning,
585 const MPI_Comm &communicator,
586 const std::vector<size_type> &n_entries_per_row)
604 const IndexSet &col_parallel_partitioning,
606 const MPI_Comm &communicator,
620 IndexSet nonlocal_partitioner = writable_rows;
622 row_parallel_partitioning.
size());
625 IndexSet tmp = writable_rows & row_parallel_partitioning;
626 Assert(tmp == row_parallel_partitioning,
628 "The set of writable rows passed to this method does not " 629 "contain the locally owned rows, which is not allowed."));
632 nonlocal_partitioner.
subtract_set(row_parallel_partitioning);
635 Epetra_Map nonlocal_map =
638 std_cxx14::make_unique<Epetra_CrsGraph>(Copy, nonlocal_map, 0);
646 template <
typename SparsityPatternType>
649 const IndexSet & row_parallel_partitioning,
650 const IndexSet & col_parallel_partitioning,
651 const SparsityPatternType &nontrilinos_sparsity_pattern,
652 const MPI_Comm & communicator,
653 const bool exchange_data)
661 nontrilinos_sparsity_pattern,
670 template <
typename SparsityPatternType>
673 const IndexSet & parallel_partitioning,
674 const SparsityPatternType &nontrilinos_sparsity_pattern,
675 const MPI_Comm & communicator,
676 const bool exchange_data)
682 nontrilinos_sparsity_pattern,
691 template <
typename SparsityPatternType>
694 const SparsityPatternType &sp,
695 const bool exchange_data)
708 template <
typename SparsityPatternType>
711 const Epetra_Map & input_col_map,
712 const SparsityPatternType &sp,
713 const bool exchange_data)
715 reinit_sp(input_row_map,
740 graph = std_cxx14::make_unique<Epetra_FECrsGraph>(*sp.
graph);
751 template <
typename SparsityPatternType>
755 const Epetra_Map rows(TrilinosWrappers::types::int_type(sp.n_rows()),
758 const Epetra_Map columns(TrilinosWrappers::types::int_type(sp.n_cols()),
775 std_cxx14::make_unique<Epetra_Map>(TrilinosWrappers::types::int_type(0),
776 TrilinosWrappers::types::int_type(0),
778 graph = std_cxx14::make_unique<Epetra_FECrsGraph>(View,
782 graph->FillComplete();
800 TrilinosWrappers::types::int_type row =
802 static_cast<TrilinosWrappers::types::int_type>(0));
809 static_cast<const Epetra_Map &>(
816 static_cast<const Epetra_Map &>(
823 static_cast<const Epetra_Map &>(
829 ierr =
graph->OptimizeStorage();
838 return graph->RowMap().LID(
839 static_cast<TrilinosWrappers::types::int_type>(i)) != -1;
856 graph->LRID(static_cast<TrilinosWrappers::types::int_type>(i)),
858 graph->LCID(static_cast<TrilinosWrappers::types::int_type>(j));
863 if (
graph->Filled() ==
false)
865 int nnz_present =
graph->NumGlobalIndices(i);
867 TrilinosWrappers::types::int_type *col_indices;
875 int ierr =
graph->ExtractGlobalRowView(
876 static_cast<TrilinosWrappers::types::int_type>(trilinos_i),
881 Assert(nnz_present == nnz_extracted,
885 TrilinosWrappers::types::int_type *el_find =
886 std::find(col_indices, col_indices + nnz_present, trilinos_j);
888 TrilinosWrappers::types::int_type local_col_index =
889 (TrilinosWrappers::types::int_type)(el_find - col_indices);
891 if (local_col_index == nnz_present)
898 int nnz_present =
graph->NumGlobalIndices(
899 static_cast<TrilinosWrappers::types::int_type>(i));
907 graph->ExtractMyRowView(trilinos_i, nnz_extracted, col_indices);
911 Assert(nnz_present == nnz_extracted,
915 int *el_find = std::find(col_indices,
916 col_indices + nnz_present,
917 static_cast<int>(trilinos_j));
919 int local_col_index = (int)(el_find - col_indices);
921 if (local_col_index == nnz_present)
935 TrilinosWrappers::types::int_type global_b = 0;
940 graph->ExtractMyRowView(i, num_entries, indices);
941 for (
unsigned int j = 0; j < (
unsigned int)num_entries; ++j)
943 if (static_cast<size_type>(
944 std::abs(static_cast<TrilinosWrappers::types::int_type>(
945 i - indices[j]))) > local_b)
947 static_cast<TrilinosWrappers::types::int_type>(i - indices[j]));
950 graph->Comm().MaxAll((TrilinosWrappers::types::int_type *)&local_b,
970 TrilinosWrappers::types::int_type
n_cols;
971 if (
graph->Filled() ==
true)
991 std::pair<SparsityPattern::size_type, SparsityPattern::size_type>
998 return std::make_pair(begin, end);
1016 int nnz =
graph->MaxNumIndices();
1018 return static_cast<unsigned int>(nnz);
1030 TrilinosWrappers::types::int_type local_row =
1031 graph->LRID(static_cast<TrilinosWrappers::types::int_type>(row));
1036 return graph->NumMyIndices(local_row);
1046 return static_cast<const Epetra_Map &
>(
graph->DomainMap());
1054 return static_cast<const Epetra_Map &
>(
graph->RangeMap());
1062 return static_cast<const Epetra_Map &
>(
graph->RowMap());
1070 return static_cast<const Epetra_Map &
>(
graph->ColMap());
1078 return graph->RangeMap().Comm();
1086 # ifdef DEAL_II_WITH_MPI 1088 const Epetra_MpiComm *mpi_comm =
1089 dynamic_cast<const Epetra_MpiComm *
>(&
graph->RangeMap().Comm());
1091 return mpi_comm->Comm();
1094 return MPI_COMM_SELF;
1114 const bool write_extended_trilinos_info)
const 1116 if (write_extended_trilinos_info)
1123 for (
int i = 0; i < graph->NumMyRows(); ++i)
1125 graph->ExtractMyRowView(i, num_entries, indices);
1126 for (
int j = 0; j < num_entries; ++j)
1130 <<
") " << std::endl;
1147 graph->ExtractMyRowView(row, num_entries, indices);
1151 const ::types::global_dof_index num_entries_ = num_entries;
1158 out << static_cast<int>(
1161 << -
static_cast<int>(
1188 const ::SparsityPattern &,
1192 const ::DynamicSparsityPattern &,
1198 const ::SparsityPattern &,
1203 const ::DynamicSparsityPattern &,
1209 const ::SparsityPattern &,
1214 const ::DynamicSparsityPattern &,
1222 const ::SparsityPattern &,
1228 const ::DynamicSparsityPattern &,
1234 DEAL_II_NAMESPACE_CLOSE
1236 #endif // DEAL_II_WITH_TRILINOS static::ExceptionBase & ExcTrilinosError(int arg1)
void print_gnuplot(std::ostream &out) const
#define AssertDimension(dim1, dim2)
const_iterator end() const
MPI_Comm get_mpi_communicator() const
std::shared_ptr< const std::vector< size_type > > colnum_cache
static::ExceptionBase & ExcIO()
size_type row_length(const size_type row) const
size_type n_elements() const
unsigned int local_size() const
TrilinosWrappers::types::int_type min_my_gid(const Epetra_BlockMap &map)
const Epetra_Map & row_partitioner() const
#define AssertThrow(cond, exc)
const Epetra_Comm & comm_self()
std::unique_ptr< Epetra_CrsGraph > nonlocal_graph
unsigned long long int global_dof_index
static::ExceptionBase & ExcTrilinosError(int arg1)
SparsityPattern * sparsity_pattern
static::ExceptionBase & ExcMessage(std::string arg1)
size_type n_nonzero_elements() const
const_iterator begin() const
TrilinosWrappers::types::int_type n_global_rows(const Epetra_CrsGraph &graph)
::types::global_dof_index size_type
std::unique_ptr< Epetra_Map > column_space_map
const Epetra_Map & domain_partitioner() const
void subtract_set(const IndexSet &other)
#define Assert(cond, exc)
static::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
TrilinosWrappers::types::int_type n_global_cols(const Epetra_CrsGraph &graph)
void print(std::ostream &out, const bool write_extended_trilinos_info=false) const
const Epetra_Map & col_partitioner() const
std::size_t memory_consumption() const
TrilinosWrappers::types::int_type n_global_entries(const Epetra_CrsGraph &graph)
bool row_is_stored_locally(const size_type i) const
Epetra_Map make_trilinos_map(const MPI_Comm &communicator=MPI_COMM_WORLD, const bool overlapping=false) const
const Epetra_Comm & trilinos_communicator() const
unsigned int n_mpi_processes(const MPI_Comm &mpi_communicator)
bool is_compressed() const
TrilinosWrappers::types::int_type n_global_elements(const Epetra_BlockMap &map)
SparsityPattern & operator=(const SparsityPattern &input_sparsity_pattern)
void copy_from(const SparsityPattern &input_sparsity_pattern)
bool exists(const size_type i, const size_type j) const
TrilinosWrappers::types::int_type max_my_gid(const Epetra_BlockMap &map)
const Epetra_Map & range_partitioner() const
static::ExceptionBase & ExcNotImplemented()
TrilinosWrappers::types::int_type global_index(const Epetra_BlockMap &map, const ::types::global_dof_index i)
unsigned int max_entries_per_row() const
std::pair< size_type, size_type > local_range() const
void reinit(const size_type m, const size_type n, const size_type n_entries_per_row=0)
std::unique_ptr< Epetra_FECrsGraph > graph
static::ExceptionBase & ExcInternalError()
size_type bandwidth() const