Reference documentation for deal.II version Git cb0bd54b52 2019-09-21 16:31:22 -0400
\(\newcommand{\dealcoloneq}{\mathrel{\vcenter{:}}=}\)
trilinos_sparsity_pattern.h
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2008 - 2018 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
16 #ifndef dealii_trilinos_sparsity_pattern_h
17 # define dealii_trilinos_sparsity_pattern_h
18 
19 
20 # include <deal.II/base/config.h>
21 
22 # ifdef DEAL_II_WITH_TRILINOS
23 
24 # include <deal.II/base/index_set.h>
25 # include <deal.II/base/subscriptor.h>
26 
27 # include <deal.II/lac/exceptions.h>
28 
29 # include <Epetra_FECrsGraph.h>
30 # include <Epetra_Map.h>
31 
32 # include <cmath>
33 # include <memory>
34 # include <vector>
35 # ifdef DEAL_II_WITH_MPI
36 # include <Epetra_MpiComm.h>
37 # include <mpi.h>
38 # else
39 # include <Epetra_SerialComm.h>
40 # endif
41 
42 
43 DEAL_II_NAMESPACE_OPEN
44 
45 // forward declarations
46 # ifndef DOXYGEN
47 class SparsityPattern;
49 
50 namespace TrilinosWrappers
51 {
52  class SparsityPattern;
53  class SparseMatrix;
54 
55  namespace SparsityPatternIterators
56  {
57  class Iterator;
58  }
59 } // namespace TrilinosWrappers
60 # endif
61 
62 namespace TrilinosWrappers
63 {
64  namespace SparsityPatternIterators
65  {
79  class Accessor
80  {
81  public:
86 
90  Accessor(const SparsityPattern *sparsity_pattern,
91  const size_type row,
92  const size_type index);
93 
97  size_type
98  row() const;
99 
103  size_type
104  index() const;
105 
109  size_type
110  column() const;
111 
115  DeclException0(ExcBeyondEndOfSparsityPattern);
116 
121  size_type,
122  size_type,
123  size_type,
124  << "You tried to access row " << arg1
125  << " of a distributed sparsity pattern, "
126  << " but only rows " << arg2 << " through " << arg3
127  << " are stored locally and can be accessed.");
128 
129  private:
134 
139 
144 
157  std::shared_ptr<const std::vector<size_type>> colnum_cache;
158 
164  void
165  visit_present_row();
166 
167  // Make enclosing class a friend.
168  friend class Iterator;
169  };
170 
176  class Iterator
177  {
178  public:
183 
188  Iterator(const SparsityPattern *sparsity_pattern,
189  const size_type row,
190  const size_type index);
191 
195  Iterator(const Iterator &i);
196 
200  Iterator &
201  operator++();
202 
206  Iterator
207  operator++(int);
208 
212  const Accessor &operator*() const;
213 
217  const Accessor *operator->() const;
218 
223  bool
224  operator==(const Iterator &) const;
225 
229  bool
230  operator!=(const Iterator &) const;
231 
237  bool
238  operator<(const Iterator &) const;
239 
243  DeclException2(ExcInvalidIndexWithinRow,
244  size_type,
245  size_type,
246  << "Attempt to access element " << arg2 << " of row "
247  << arg1 << " which doesn't have that many elements.");
248 
249  private:
254 
256  };
257 
258  } // namespace SparsityPatternIterators
259 
260 
280  {
281  public:
286 
291 
299  SparsityPattern();
300 
315  SparsityPattern(const size_type m,
316  const size_type n,
317  const size_type n_entries_per_row = 0);
318 
327  SparsityPattern(const size_type m,
328  const size_type n,
329  const std::vector<size_type> &n_entries_per_row);
330 
335  SparsityPattern(SparsityPattern &&other) noexcept;
336 
341  SparsityPattern(const SparsityPattern &input_sparsity_pattern);
342 
346  virtual ~SparsityPattern() override = default;
347 
359  void
360  reinit(const size_type m,
361  const size_type n,
362  const size_type n_entries_per_row = 0);
363 
372  void
373  reinit(const size_type m,
374  const size_type n,
375  const std::vector<size_type> &n_entries_per_row);
376 
381  void
382  copy_from(const SparsityPattern &input_sparsity_pattern);
383 
389  template <typename SparsityPatternType>
390  void
391  copy_from(const SparsityPatternType &nontrilinos_sparsity_pattern);
392 
400  operator=(const SparsityPattern &input_sparsity_pattern);
401 
409  void
410  clear();
411 
421  void
422  compress();
424 
428 
443  DEAL_II_DEPRECATED
444  SparsityPattern(const Epetra_Map &parallel_partitioning,
445  const size_type n_entries_per_row = 0);
446 
459  DEAL_II_DEPRECATED
460  SparsityPattern(const Epetra_Map & parallel_partitioning,
461  const std::vector<size_type> &n_entries_per_row);
462 
481  DEAL_II_DEPRECATED
482  SparsityPattern(const Epetra_Map &row_parallel_partitioning,
483  const Epetra_Map &col_parallel_partitioning,
484  const size_type n_entries_per_row = 0);
485 
499  DEAL_II_DEPRECATED
500  SparsityPattern(const Epetra_Map & row_parallel_partitioning,
501  const Epetra_Map & col_parallel_partitioning,
502  const std::vector<size_type> &n_entries_per_row);
503 
520  DEAL_II_DEPRECATED
521  void
522  reinit(const Epetra_Map &parallel_partitioning,
523  const size_type n_entries_per_row = 0);
524 
537  DEAL_II_DEPRECATED
538  void
539  reinit(const Epetra_Map & parallel_partitioning,
540  const std::vector<size_type> &n_entries_per_row);
541 
560  DEAL_II_DEPRECATED
561  void
562  reinit(const Epetra_Map &row_parallel_partitioning,
563  const Epetra_Map &col_parallel_partitioning,
564  const size_type n_entries_per_row = 0);
565 
579  DEAL_II_DEPRECATED
580  void
581  reinit(const Epetra_Map & row_parallel_partitioning,
582  const Epetra_Map & col_parallel_partitioning,
583  const std::vector<size_type> &n_entries_per_row);
584 
595  template <typename SparsityPatternType>
596  DEAL_II_DEPRECATED void
597  reinit(const Epetra_Map & row_parallel_partitioning,
598  const Epetra_Map & col_parallel_partitioning,
599  const SparsityPatternType &nontrilinos_sparsity_pattern,
600  const bool exchange_data = false);
601 
612  template <typename SparsityPatternType>
613  DEAL_II_DEPRECATED void
614  reinit(const Epetra_Map & parallel_partitioning,
615  const SparsityPatternType &nontrilinos_sparsity_pattern,
616  const bool exchange_data = false);
618 
622 
634  SparsityPattern(const IndexSet &parallel_partitioning,
635  const MPI_Comm &communicator = MPI_COMM_WORLD,
636  const size_type n_entries_per_row = 0);
637 
648  SparsityPattern(const IndexSet & parallel_partitioning,
649  const MPI_Comm & communicator,
650  const std::vector<size_type> &n_entries_per_row);
651 
666  SparsityPattern(const IndexSet &row_parallel_partitioning,
667  const IndexSet &col_parallel_partitioning,
668  const MPI_Comm &communicator = MPI_COMM_WORLD,
669  const size_type n_entries_per_row = 0);
670 
682  SparsityPattern(const IndexSet & row_parallel_partitioning,
683  const IndexSet & col_parallel_partitioning,
684  const MPI_Comm & communicator,
685  const std::vector<size_type> &n_entries_per_row);
686 
713  SparsityPattern(const IndexSet &row_parallel_partitioning,
714  const IndexSet &col_parallel_partitioning,
715  const IndexSet &writable_rows,
716  const MPI_Comm &communicator = MPI_COMM_WORLD,
717  const size_type n_entries_per_row = 0);
718 
734  void
735  reinit(const IndexSet &parallel_partitioning,
736  const MPI_Comm &communicator = MPI_COMM_WORLD,
737  const size_type n_entries_per_row = 0);
738 
749  void
750  reinit(const IndexSet & parallel_partitioning,
751  const MPI_Comm & communicator,
752  const std::vector<size_type> &n_entries_per_row);
753 
770  void
771  reinit(const IndexSet &row_parallel_partitioning,
772  const IndexSet &col_parallel_partitioning,
773  const MPI_Comm &communicator = MPI_COMM_WORLD,
774  const size_type n_entries_per_row = 0);
775 
801  void
802  reinit(const IndexSet &row_parallel_partitioning,
803  const IndexSet &col_parallel_partitioning,
804  const IndexSet &writeable_rows,
805  const MPI_Comm &communicator = MPI_COMM_WORLD,
806  const size_type n_entries_per_row = 0);
807 
812  void
813  reinit(const IndexSet & row_parallel_partitioning,
814  const IndexSet & col_parallel_partitioning,
815  const MPI_Comm & communicator,
816  const std::vector<size_type> &n_entries_per_row);
817 
827  template <typename SparsityPatternType>
828  void
829  reinit(const IndexSet & row_parallel_partitioning,
830  const IndexSet & col_parallel_partitioning,
831  const SparsityPatternType &nontrilinos_sparsity_pattern,
832  const MPI_Comm & communicator = MPI_COMM_WORLD,
833  const bool exchange_data = false);
834 
843  template <typename SparsityPatternType>
844  void
845  reinit(const IndexSet & parallel_partitioning,
846  const SparsityPatternType &nontrilinos_sparsity_pattern,
847  const MPI_Comm & communicator = MPI_COMM_WORLD,
848  const bool exchange_data = false);
850 
854 
859  bool
860  is_compressed() const;
861 
865  unsigned int
866  max_entries_per_row() const;
867 
871  size_type
872  n_rows() const;
873 
877  size_type
878  n_cols() const;
879 
889  unsigned int
890  local_size() const;
891 
900  std::pair<size_type, size_type>
901  local_range() const;
902 
907  bool
908  in_local_range(const size_type index) const;
909 
913  size_type
914  n_nonzero_elements() const;
915 
924  size_type
925  row_length(const size_type row) const;
926 
933  size_type
934  bandwidth() const;
935 
940  bool
941  empty() const;
942 
947  bool
948  exists(const size_type i, const size_type j) const;
949 
954  bool
955  row_is_stored_locally(const size_type i) const;
956 
961  std::size_t
962  memory_consumption() const;
963 
965 
972  void
973  add(const size_type i, const size_type j);
974 
975 
979  template <typename ForwardIterator>
980  void
981  add_entries(const size_type row,
982  ForwardIterator begin,
983  ForwardIterator end,
984  const bool indices_are_sorted = false);
986 
990 
995  const Epetra_FECrsGraph &
996  trilinos_sparsity_pattern() const;
997 
1006  DEAL_II_DEPRECATED
1007  const Epetra_Map &
1008  domain_partitioner() const;
1009 
1018  DEAL_II_DEPRECATED
1019  const Epetra_Map &
1020  range_partitioner() const;
1021 
1029  DEAL_II_DEPRECATED
1030  const Epetra_Map &
1031  row_partitioner() const;
1032 
1042  DEAL_II_DEPRECATED
1043  const Epetra_Map &
1044  col_partitioner() const;
1045 
1051  DEAL_II_DEPRECATED
1052  const Epetra_Comm &
1053  trilinos_communicator() const;
1054 
1058  MPI_Comm
1059  get_mpi_communicator() const;
1061 
1066 
1072  IndexSet
1073  locally_owned_domain_indices() const;
1074 
1080  IndexSet
1081  locally_owned_range_indices() const;
1082 
1084 
1089 
1094  begin() const;
1095 
1100  end() const;
1101 
1111  begin(const size_type r) const;
1112 
1122  end(const size_type r) const;
1123 
1125 
1129 
1135  void
1136  write_ascii();
1137 
1145  void
1146  print(std::ostream &out,
1147  const bool write_extended_trilinos_info = false) const;
1148 
1163  void
1164  print_gnuplot(std::ostream &out) const;
1165 
1167 
1175  int,
1176  << "An error with error number " << arg1
1177  << " occurred while calling a Trilinos function");
1178 
1182  DeclException2(ExcInvalidIndex,
1183  size_type,
1184  size_type,
1185  << "The entry with index <" << arg1 << ',' << arg2
1186  << "> does not exist.");
1187 
1192  ExcSourceEqualsDestination,
1193  "You are attempting an operation on two sparsity patterns that "
1194  "are the same object, but the operation requires that the "
1195  "two objects are in fact different.");
1196 
1200  DeclException4(ExcAccessToNonLocalElement,
1201  size_type,
1202  size_type,
1203  size_type,
1204  size_type,
1205  << "You tried to access element (" << arg1 << "/" << arg2
1206  << ")"
1207  << " of a distributed matrix, but only rows " << arg3
1208  << " through " << arg4
1209  << " are stored locally and can be accessed.");
1210 
1214  DeclException2(ExcAccessToNonPresentElement,
1215  size_type,
1216  size_type,
1217  << "You tried to access element (" << arg1 << "/" << arg2
1218  << ")"
1219  << " of a sparse matrix, but it appears to not"
1220  << " exist in the Trilinos sparsity pattern.");
1222  private:
1227  std::unique_ptr<Epetra_Map> column_space_map;
1228 
1234  std::unique_ptr<Epetra_FECrsGraph> graph;
1235 
1242  std::unique_ptr<Epetra_CrsGraph> nonlocal_graph;
1243 
1244  friend class TrilinosWrappers::SparseMatrix;
1247  };
1248 
1249 
1250 
1251  // ----------------------- inline and template functions --------------------
1252 
1253 
1254 # ifndef DOXYGEN
1255 
1256  namespace SparsityPatternIterators
1257  {
1258  inline Accessor::Accessor(const SparsityPattern *sp,
1259  const size_type row,
1260  const size_type index)
1261  : sparsity_pattern(const_cast<SparsityPattern *>(sp))
1262  , a_row(row)
1263  , a_index(index)
1264  {
1265  visit_present_row();
1266  }
1267 
1268 
1269 
1270  inline Accessor::size_type
1271  Accessor::row() const
1272  {
1273  Assert(a_row < sparsity_pattern->n_rows(),
1274  ExcBeyondEndOfSparsityPattern());
1275  return a_row;
1276  }
1277 
1278 
1279 
1280  inline Accessor::size_type
1281  Accessor::column() const
1282  {
1283  Assert(a_row < sparsity_pattern->n_rows(),
1284  ExcBeyondEndOfSparsityPattern());
1285  return (*colnum_cache)[a_index];
1286  }
1287 
1288 
1289 
1290  inline Accessor::size_type
1291  Accessor::index() const
1292  {
1293  Assert(a_row < sparsity_pattern->n_rows(),
1294  ExcBeyondEndOfSparsityPattern());
1295  return a_index;
1296  }
1297 
1298 
1299 
1300  inline Iterator::Iterator(const SparsityPattern *sp,
1301  const size_type row,
1302  const size_type index)
1303  : accessor(sp, row, index)
1304  {}
1305 
1306 
1307 
1308  inline Iterator::Iterator(const Iterator &) = default;
1309 
1310 
1311 
1312  inline Iterator &
1313  Iterator::operator++()
1314  {
1315  Assert(accessor.a_row < accessor.sparsity_pattern->n_rows(),
1316  ExcIteratorPastEnd());
1317 
1318  ++accessor.a_index;
1319 
1320  // If at end of line: do one step, then cycle until we find a row with a
1321  // nonzero number of entries that is stored locally.
1322  if (accessor.a_index >= accessor.colnum_cache->size())
1323  {
1324  accessor.a_index = 0;
1325  ++accessor.a_row;
1326 
1327  while (accessor.a_row < accessor.sparsity_pattern->n_rows())
1328  {
1329  const auto row_length =
1330  accessor.sparsity_pattern->row_length(accessor.a_row);
1331  if (row_length == 0 ||
1332  !accessor.sparsity_pattern->row_is_stored_locally(
1333  accessor.a_row))
1334  ++accessor.a_row;
1335  else
1336  break;
1337  }
1338 
1339  accessor.visit_present_row();
1340  }
1341  return *this;
1342  }
1343 
1344 
1345 
1346  inline Iterator
1347  Iterator::operator++(int)
1348  {
1349  const Iterator old_state = *this;
1350  ++(*this);
1351  return old_state;
1352  }
1353 
1354 
1355 
1356  inline const Accessor &Iterator::operator*() const
1357  {
1358  return accessor;
1359  }
1360 
1361 
1362 
1363  inline const Accessor *Iterator::operator->() const
1364  {
1365  return &accessor;
1366  }
1367 
1368 
1369 
1370  inline bool
1371  Iterator::operator==(const Iterator &other) const
1372  {
1373  return (accessor.a_row == other.accessor.a_row &&
1374  accessor.a_index == other.accessor.a_index);
1375  }
1376 
1377 
1378 
1379  inline bool
1380  Iterator::operator!=(const Iterator &other) const
1381  {
1382  return !(*this == other);
1383  }
1384 
1385 
1386 
1387  inline bool
1388  Iterator::operator<(const Iterator &other) const
1389  {
1390  return (accessor.row() < other.accessor.row() ||
1391  (accessor.row() == other.accessor.row() &&
1392  accessor.index() < other.accessor.index()));
1393  }
1394 
1395  } // namespace SparsityPatternIterators
1396 
1397 
1398 
1400  SparsityPattern::begin() const
1401  {
1402  const size_type first_valid_row = this->local_range().first;
1403  return const_iterator(this, first_valid_row, 0);
1404  }
1405 
1406 
1407 
1409  SparsityPattern::end() const
1410  {
1411  return const_iterator(this, n_rows(), 0);
1412  }
1413 
1414 
1415 
1417  SparsityPattern::begin(const size_type r) const
1418  {
1419  Assert(r < n_rows(), ExcIndexRangeType<size_type>(r, 0, n_rows()));
1420  if (row_length(r) > 0)
1421  return const_iterator(this, r, 0);
1422  else
1423  return end(r);
1424  }
1425 
1426 
1427 
1429  SparsityPattern::end(const size_type r) const
1430  {
1431  Assert(r < n_rows(), ExcIndexRangeType<size_type>(r, 0, n_rows()));
1432 
1433  // place the iterator on the first entry
1434  // past this line, or at the end of the
1435  // matrix
1436  for (size_type i = r + 1; i < n_rows(); ++i)
1437  if (row_length(i) > 0)
1438  return const_iterator(this, i, 0);
1439 
1440  // if there is no such line, then take the
1441  // end iterator of the matrix
1442  return end();
1443  }
1444 
1445 
1446 
1447  inline bool
1448  SparsityPattern::in_local_range(const size_type index) const
1449  {
1450  TrilinosWrappers::types::int_type begin, end;
1451 # ifndef DEAL_II_WITH_64BIT_INDICES
1452  begin = graph->RowMap().MinMyGID();
1453  end = graph->RowMap().MaxMyGID() + 1;
1454 # else
1455  begin = graph->RowMap().MinMyGID64();
1456  end = graph->RowMap().MaxMyGID64() + 1;
1457 # endif
1458 
1459  return ((index >= static_cast<size_type>(begin)) &&
1460  (index < static_cast<size_type>(end)));
1461  }
1462 
1463 
1464 
1465  inline bool
1467  {
1468  return graph->Filled();
1469  }
1470 
1471 
1472 
1473  inline bool
1474  SparsityPattern::empty() const
1475  {
1476  return ((n_rows() == 0) && (n_cols() == 0));
1477  }
1478 
1479 
1480 
1481  inline void
1482  SparsityPattern::add(const size_type i, const size_type j)
1483  {
1484  add_entries(i, &j, &j + 1);
1485  }
1486 
1487 
1488 
1489  template <typename ForwardIterator>
1490  inline void
1492  ForwardIterator begin,
1493  ForwardIterator end,
1494  const bool /*indices_are_sorted*/)
1495  {
1496  if (begin == end)
1497  return;
1498 
1499  // verify that the size of the data type Trilinos expects matches that the
1500  // iterator points to. we allow for some slippage between signed and
1501  // unsigned and only compare that they are both either 32 or 64 bit. to
1502  // write this test properly, not that we cannot compare the size of
1503  // '*begin' because 'begin' may be an iterator and '*begin' may be an
1504  // accessor class. consequently, we need to somehow get an actual value
1505  // from it which we can by evaluating an expression such as when
1506  // multiplying the value produced by 2
1507  Assert(sizeof(TrilinosWrappers::types::int_type) == sizeof((*begin) * 2),
1508  ExcNotImplemented());
1509 
1510  TrilinosWrappers::types::int_type *col_index_ptr =
1511  reinterpret_cast<TrilinosWrappers::types::int_type *>(
1512  const_cast<typename std::decay<decltype(*begin)>::type *>(&*begin));
1513  // Check at least for the first index that the conversion actually works
1514  AssertDimension(*col_index_ptr, *begin);
1515  TrilinosWrappers::types::int_type trilinos_row_index = row;
1516  const int n_cols = static_cast<int>(end - begin);
1517 
1518  int ierr;
1519  if (row_is_stored_locally(row))
1520  ierr =
1521  graph->InsertGlobalIndices(trilinos_row_index, n_cols, col_index_ptr);
1522  else if (nonlocal_graph.get() != nullptr)
1523  {
1524  // this is the case when we have explicitly set the off-processor rows
1525  // and want to create a separate matrix object for them (to retain
1526  // thread-safety)
1527  Assert(nonlocal_graph->RowMap().LID(
1528  static_cast<TrilinosWrappers::types::int_type>(row)) != -1,
1529  ExcMessage("Attempted to write into off-processor matrix row "
1530  "that has not be specified as being writable upon "
1531  "initialization"));
1532  ierr = nonlocal_graph->InsertGlobalIndices(trilinos_row_index,
1533  n_cols,
1534  col_index_ptr);
1535  }
1536  else
1537  ierr = graph->InsertGlobalIndices(1,
1538  &trilinos_row_index,
1539  n_cols,
1540  col_index_ptr);
1541 
1542  AssertThrow(ierr >= 0, ExcTrilinosError(ierr));
1543  }
1544 
1545 
1546 
1547  inline const Epetra_FECrsGraph &
1549  {
1550  return *graph;
1551  }
1552 
1553 
1554 
1555  inline IndexSet
1557  {
1558  return IndexSet(graph->DomainMap());
1559  }
1560 
1561 
1562 
1563  inline IndexSet
1565  {
1566  return IndexSet(graph->RangeMap());
1567  }
1568 
1569 # endif // DOXYGEN
1570 } // namespace TrilinosWrappers
1571 
1572 
1573 DEAL_II_NAMESPACE_CLOSE
1574 
1575 
1576 # endif // DEAL_II_WITH_TRILINOS
1577 
1578 
1579 /*-------------------- trilinos_sparsity_pattern.h --------------------*/
1580 
1581 #endif
1582 /*-------------------- trilinos_sparsity_pattern.h --------------------*/
static ::ExceptionBase & ExcTrilinosError(int arg1)
#define DeclException2(Exception2, type1, type2, outsequence)
Definition: exceptions.h:541
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1567
DEAL_II_CONSTEXPR SymmetricTensor< rank_, dim, Number > operator*(const SymmetricTensor< rank_, dim, Number > &t, const Number &factor)
std::shared_ptr< const std::vector< size_type > > colnum_cache
size_type row_length(const size_type row) const
IndexSet locally_owned_range_indices() const
const Epetra_FECrsGraph & trilinos_sparsity_pattern() const
static ::ExceptionBase & ExcAccessToNonlocalRow(std::size_t arg1, std::size_t arg2, std::size_t arg3)
#define AssertThrow(cond, exc)
Definition: exceptions.h:1519
void add(const size_type i, const size_type j)
void add_entries(const size_type row, ForwardIterator begin, ForwardIterator end, const bool indices_are_sorted=false)
SparsityPatternIterators::Iterator const_iterator
std::unique_ptr< Epetra_CrsGraph > nonlocal_graph
const_iterator begin() const
static ::ExceptionBase & ExcTrilinosError(int arg1)
static ::ExceptionBase & ExcMessage(std::string arg1)
#define DeclException1(Exception1, type1, outsequence)
Definition: exceptions.h:518
std::unique_ptr< Epetra_Map > column_space_map
#define Assert(cond, exc)
Definition: exceptions.h:1407
#define DeclExceptionMsg(Exception, defaulttext)
Definition: exceptions.h:496
#define DeclException0(Exception0)
Definition: exceptions.h:473
const_iterator end() const
static ::ExceptionBase & ExcIteratorPastEnd()
unsigned int global_dof_index
Definition: types.h:89
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence)
Definition: exceptions.h:587
static ::ExceptionBase & ExcNotImplemented()
#define DeclException3(Exception3, type1, type2, type3, outsequence)
Definition: exceptions.h:564
bool in_local_range(const size_type index) const
IndexSet locally_owned_domain_indices() const
std::pair< size_type, size_type > local_range() const
std::unique_ptr< Epetra_FECrsGraph > graph
Accessor(const SparsityPattern *sparsity_pattern, const size_type row, const size_type index)
bool row_is_stored_locally(const size_type i) const