185 const SparsityPatternType &sparsity_pattern)
190 sparsity_pattern.n_rows()),
191 sparsity_pattern.n_rows());
193 sparsity_pattern.n_cols()),
194 sparsity_pattern.n_cols());
196 Assert(sparsity_pattern.n_rows() == local_rows.
size(),
198 "SparsityPattern and IndexSet have different number of rows"));
200 sparsity_pattern.n_cols() == local_columns.
size(),
202 "SparsityPattern and IndexSet have different number of columns"));
204 ExcMessage(
"PETSc only supports contiguous row/column ranges"));
216 row_owners == sparsity_pattern.n_rows(),
219 "Each row has to be owned by exactly one owner (n_rows()=") +
220 std::to_string(sparsity_pattern.n_rows()) +
221 " but sum(local_rows.n_elements())=" +
222 std::to_string(row_owners) +
")"));
224 col_owners == sparsity_pattern.n_cols(),
227 "Each column has to be owned by exactly one owner (n_cols()=") +
228 std::to_string(sparsity_pattern.n_cols()) +
229 " but sum(local_columns.n_elements())=" +
230 std::to_string(col_owners) +
")"));
236 PetscErrorCode ierr = MatCreate(communicator, &
matrix);
239 ierr = MatSetSizes(
matrix,
242 sparsity_pattern.n_rows(),
243 sparsity_pattern.n_cols());
249 ierr = MatSetType(
matrix, MATAIJ);
273 const PetscInt local_row_end =
283 std::vector<PetscInt> rowstart_in_window(local_row_end -
288 unsigned int n_cols = 0;
289 for (PetscInt i = local_row_start; i < local_row_end; ++i)
291 const PetscInt
row_length = sparsity_pattern.row_length(i);
292 rowstart_in_window[i + 1 - local_row_start] =
293 rowstart_in_window[i - local_row_start] +
row_length;
296 colnums_in_window.resize(n_cols + 1, -1);
302 PetscInt *ptr = colnums_in_window.data();
303 for (PetscInt i = local_row_start; i < local_row_end; ++i)
304 for (
typename SparsityPatternType::iterator p =
305 sparsity_pattern.begin(i);
306 p != sparsity_pattern.end(i);
319 ierr = MatMPIAIJSetPreallocationCSR(
matrix,
320 rowstart_in_window.data(),
321 colnums_in_window.data(),
323 ierr = MatSeqAIJSetPreallocationCSR(
matrix,
324 rowstart_in_window.data(),
325 colnums_in_window.data(),
333 ierr = MatSeqAIJSetPreallocationCSR(
matrix, &i, &i,
nullptr);
335 ierr = MatMPIAIJSetPreallocationCSR(
matrix, &i, &i,
nullptr);
351 const SparsityPatternType &sparsity_pattern,
352 const std::vector<size_type> &local_rows_per_process,
353 const std::vector<size_type> &local_columns_per_process,
354 const unsigned int this_process,
355 const bool preset_nonzero_locations)
357 Assert(local_rows_per_process.size() == local_columns_per_process.size(),
359 local_columns_per_process.size()));
365 sparsity_pattern.n_rows()),
366 sparsity_pattern.n_rows());
368 sparsity_pattern.n_cols()),
369 sparsity_pattern.n_cols());
379 for (
unsigned int p = 0; p < this_process; ++p)
380 local_row_start += local_rows_per_process[p];
382 local_row_start + local_rows_per_process[this_process];
387 PetscErrorCode ierr = MatCreate(communicator, &
matrix);
390 ierr = MatSetSizes(
matrix,
391 local_rows_per_process[this_process],
392 local_columns_per_process[this_process],
393 sparsity_pattern.n_rows(),
394 sparsity_pattern.n_cols());
400 ierr = MatSetType(
matrix, MATAIJ);
416 if (preset_nonzero_locations ==
true)
429 std::vector<PetscInt> rowstart_in_window(local_row_end -
435 for (
size_type i = local_row_start; i < local_row_end; ++i)
438 const auto row_start =
439 rowstart_in_window[i - local_row_start] +
row_length;
440 const auto petsc_row_start =
static_cast<PetscInt
>(row_start);
442 rowstart_in_window[i + 1 - local_row_start] = petsc_row_start;
445 colnums_in_window.resize(n_cols + 1, -1);
451 PetscInt *ptr = colnums_in_window.data();
452 for (
size_type i = local_row_start; i < local_row_end; ++i)
453 for (
typename SparsityPatternType::iterator p =
454 sparsity_pattern.begin(i);
455 p != sparsity_pattern.end(i);
458 const auto petsc_column =
static_cast<PetscInt
>(p->column());
472 ierr = MatSeqAIJSetPreallocationCSR(
matrix,
473 rowstart_in_window.data(),
474 colnums_in_window.data(),
476 ierr = MatMPIAIJSetPreallocationCSR(
matrix,
477 rowstart_in_window.data(),
478 colnums_in_window.data(),
494 const IndexSet &local_active_columns,
495 const SparsityPatternType &sparsity_pattern)
500 sparsity_pattern.n_rows()),
501 sparsity_pattern.n_rows());
503 sparsity_pattern.n_cols()),
504 sparsity_pattern.n_cols());
506# if DEAL_II_PETSC_VERSION_GTE(3, 10, 0)
507 Assert(sparsity_pattern.n_rows() == local_rows.
size(),
509 "SparsityPattern and IndexSet have different number of rows."));
511 sparsity_pattern.n_cols() == local_columns.
size(),
513 "SparsityPattern and IndexSet have different number of columns"));
515 ExcMessage(
"PETSc only supports contiguous row/column ranges"));
527 row_owners == sparsity_pattern.n_rows(),
530 "Each row has to be owned by exactly one owner (n_rows()=") +
531 std::to_string(sparsity_pattern.n_rows()) +
532 " but sum(local_rows.n_elements())=" +
533 std::to_string(row_owners) +
")"));
535 col_owners == sparsity_pattern.n_cols(),
538 "Each column has to be owned by exactly one owner (n_cols()=") +
539 std::to_string(sparsity_pattern.n_cols()) +
540 " but sum(local_columns.n_elements())=" +
541 std::to_string(col_owners) +
")"));
550 std::vector<PetscInt> idx_glob_row(n_local_active_rows);
551 std::vector<PetscInt> idx_glob_col(n_local_active_cols);
562 IS is_glob_row, is_glob_col;
564 ISLocalToGlobalMapping l2gmap_row;
565 ierr = ISCreateGeneral(communicator,
571 ierr = ISLocalToGlobalMappingCreateIS(is_glob_row, &l2gmap_row);
573 ierr = ISDestroy(&is_glob_row);
576 ISLocalToGlobalMappingViewFromOptions(l2gmap_row,
nullptr,
"-view_map");
580 ISLocalToGlobalMapping l2gmap_col;
581 ierr = ISCreateGeneral(communicator,
587 ierr = ISLocalToGlobalMappingCreateIS(is_glob_col, &l2gmap_col);
589 ierr = ISDestroy(&is_glob_col);
592 ISLocalToGlobalMappingViewFromOptions(l2gmap_col,
nullptr,
"-view_map");
596 ierr = MatCreateIS(communicator,
600 sparsity_pattern.n_rows(),
601 sparsity_pattern.n_cols(),
606 ierr = ISLocalToGlobalMappingDestroy(&l2gmap_row);
608 ierr = ISLocalToGlobalMappingDestroy(&l2gmap_col);
625 ierr = MatISGetLocalMat(
matrix, &local_matrix);
627 ierr = MatSetType(local_matrix,
636 const PetscInt local_row_start = 0;
637 const PetscInt local_row_end = local_active_rows.
n_elements();
642 std::vector<PetscInt> rowstart_in_window(local_row_end -
646 unsigned int global_row_index = 0;
648 unsigned int n_cols = 0;
649 unsigned int global_row_index = 0;
650 for (PetscInt i = local_row_start; i < local_row_end; ++i)
654 sparsity_pattern.row_length(global_row_index);
655 rowstart_in_window[i + 1 - local_row_start] =
656 rowstart_in_window[i - local_row_start] +
row_length;
659 colnums_in_window.resize(n_cols + 1, -1);
666 std::map<unsigned int, unsigned int> loc_act_cols_inv;
667 for (
unsigned int i = 0; i < local_active_columns.
n_elements(); ++i)
673 PetscInt *ptr = colnums_in_window.data();
674 for (PetscInt i = local_row_start; i < local_row_end; ++i)
677 for (
typename SparsityPatternType::iterator p =
678 sparsity_pattern.begin(global_row_index);
679 p != sparsity_pattern.end(global_row_index);
681 *ptr = loc_act_cols_inv[p->column()];
688 ierr = MatSeqAIJSetPreallocationCSR(local_matrix,
689 rowstart_in_window.data(),
690 colnums_in_window.data(),
697 ierr = MatSeqAIJSetPreallocationCSR(local_matrix, &i, &i,
nullptr);
706 ierr = MatISRestoreLocalMat(
matrix, &local_matrix);
713 (void)local_active_rows;
715 (void)local_active_columns;
716 (void)sparsity_pattern;
719 "BDDC preconditioner requires PETSc 3.10.0 or newer"));