16 #ifndef dealii_trilinos_vector_h 17 #define dealii_trilinos_vector_h 20 #include <deal.II/base/config.h> 22 #ifdef DEAL_II_WITH_TRILINOS 23 # include <deal.II/base/index_set.h> 24 # include <deal.II/base/mpi.h> 25 # include <deal.II/base/subscriptor.h> 26 # include <deal.II/base/utilities.h> 28 # include <deal.II/lac/exceptions.h> 29 # include <deal.II/lac/vector.h> 30 # include <deal.II/lac/vector_operation.h> 31 # include <deal.II/lac/vector_type_traits.h> 33 # include <Epetra_ConfigDefs.h> 38 # ifdef DEAL_II_WITH_MPI // only if MPI is installed 39 # include <Epetra_MpiComm.h> 42 # include <Epetra_SerialComm.h> 44 # include <Epetra_FEVector.h> 45 # include <Epetra_LocalMap.h> 46 # include <Epetra_Map.h> 48 DEAL_II_NAMESPACE_OPEN
98 VectorReference(MPI::Vector &vector,
const size_type index);
112 const VectorReference &
113 operator=(
const VectorReference &r)
const;
119 operator=(
const VectorReference &r);
124 const VectorReference &
125 operator=(
const TrilinosScalar &s)
const;
130 const VectorReference &
131 operator+=(
const TrilinosScalar &s)
const;
136 const VectorReference &
137 operator-=(
const TrilinosScalar &s)
const;
142 const VectorReference &
143 operator*=(
const TrilinosScalar &s)
const;
148 const VectorReference &
149 operator/=(
const TrilinosScalar &s)
const;
155 operator TrilinosScalar()
const;
162 <<
"An error with error number " << arg1
163 <<
" occurred while calling a Trilinos function");
174 const size_type index;
180 friend class ::TrilinosWrappers::MPI::Vector;
187 # ifndef DEAL_II_WITH_64BIT_INDICES 192 gid(
const Epetra_BlockMap &map,
int i)
201 gid(
const Epetra_BlockMap &map,
int i)
402 using real_type = TrilinosScalar;
406 using reference = internal::VectorReference;
407 using const_reference =
const internal::VectorReference;
444 const MPI_Comm &communicator = MPI_COMM_WORLD);
459 const MPI_Comm &communicator = MPI_COMM_WORLD);
477 const MPI_Comm &communicator = MPI_COMM_WORLD);
491 template <
typename Number>
493 const ::Vector<Number> &v,
494 const MPI_Comm & communicator = MPI_COMM_WORLD);
505 ~
Vector() override = default;
539 const
bool omit_zeroing_entries = false,
540 const
bool allow_different_maps = false);
565 reinit(const
IndexSet ¶llel_partitioning,
566 const MPI_Comm &communicator = MPI_COMM_WORLD,
567 const
bool omit_zeroing_entries = false);
595 reinit(const
IndexSet &locally_owned_entries,
597 const MPI_Comm &communicator = MPI_COMM_WORLD,
598 const
bool vector_writable = false);
604 reinit(const
BlockVector &v, const
bool import_data = false);
638 operator=(const TrilinosScalar s);
646 operator=(const
Vector &v);
653 operator=(
Vector &&v) noexcept;
662 template <typename Number>
664 operator=(const ::
Vector<Number> &v);
684 import_nonlocal_data_for_fe(
694 operator==(const
Vector &v) const;
702 operator!=(const
Vector &v) const;
745 std::pair<size_type, size_type>
756 in_local_range(const size_type index) const;
772 locally_owned_elements() const;
782 has_ghost_elements() const;
791 update_ghost_values() const;
797 TrilinosScalar operator*(const
Vector &vec) const;
841 lp_norm(const TrilinosScalar p) const;
869 add_and_dot(const TrilinosScalar a, const
Vector &V, const
Vector &W);
885 is_non_negative() const;
902 operator()(const size_type index);
912 operator()(const size_type index) const;
919 reference operator[](const size_type index);
926 TrilinosScalar operator[](const size_type index) const;
944 extract_subvector_to(const
std::vector<size_type> &indices,
945 std::vector<TrilinosScalar> & values) const;
974 template <typename ForwardIterator, typename OutputIterator>
976 extract_subvector_to(ForwardIterator indices_begin,
977 const ForwardIterator indices_end,
978 OutputIterator values_begin) const;
1029 set(const
std::vector<size_type> & indices,
1030 const
std::vector<TrilinosScalar> &values);
1037 set(const
std::vector<size_type> & indices,
1038 const ::
Vector<TrilinosScalar> &values);
1046 set(const size_type n_elements,
1047 const size_type * indices,
1048 const TrilinosScalar *values);
1055 add(const
std::vector<size_type> & indices,
1056 const
std::vector<TrilinosScalar> &values);
1063 add(const
std::vector<size_type> & indices,
1064 const ::
Vector<TrilinosScalar> &values);
1072 add(const size_type n_elements,
1073 const size_type * indices,
1074 const TrilinosScalar *values);
1080 operator*=(const TrilinosScalar factor);
1086 operator/=(const TrilinosScalar factor);
1092 operator+=(const
Vector &V);
1098 operator-=(const
Vector &V);
1105 add(const TrilinosScalar s);
1120 add(const
Vector &V, const
bool allow_different_maps = false);
1126 add(const TrilinosScalar a, const
Vector &V);
1132 add(const TrilinosScalar a,
1134 const TrilinosScalar b,
1142 sadd(const TrilinosScalar s, const
Vector &V);
1148 sadd(const TrilinosScalar s, const TrilinosScalar a, const
Vector &V);
1156 scale(const
Vector &scaling_factors);
1162 equ(const TrilinosScalar a, const
Vector &V);
1174 const Epetra_MultiVector &
1175 trilinos_vector() const;
1189 vector_partitioner() const;
1199 print(
std::ostream & out,
1200 const
unsigned int precision = 3,
1201 const
bool scientific = true,
1202 const
bool across = true) const;
1224 memory_consumption() const;
1231 get_mpi_communicator() const;
1244 << "An error with error number " << arg1
1245 << " occurred while calling a Trilinos function");
1251 ExcAccessToNonLocalElement,
1256 << "You tried to access element " << arg1
1257 << " of a distributed vector, but this element is not stored "
1258 << "on the current processor. Note: There are " << arg2
1259 << " elements stored "
1260 << "on the current processor from within the range " << arg3
1261 << " through " << arg4
1262 << " but Trilinos vectors need not store contiguous "
1263 << "ranges on each processor, and not every element in "
1264 << "this range may in fact be stored locally.");
1278 Epetra_CombineMode last_action;
1297 std::unique_ptr<Epetra_FEVector> vector;
1304 std::unique_ptr<Epetra_MultiVector> nonlocal_vector;
1341 inline VectorReference::VectorReference(
MPI::Vector & vector,
1342 const size_type index)
1348 inline const VectorReference &
1349 VectorReference::operator=(
const VectorReference &r)
const 1355 *
this =
static_cast<TrilinosScalar
>(r);
1362 inline VectorReference &
1363 VectorReference::operator=(
const VectorReference &r)
1366 *
this =
static_cast<TrilinosScalar
>(r);
1372 inline const VectorReference &
1373 VectorReference::operator=(
const TrilinosScalar &value)
const 1375 vector.
set(1, &index, &value);
1381 inline const VectorReference &
1382 VectorReference::operator+=(
const TrilinosScalar &value)
const 1384 vector.
add(1, &index, &value);
1390 inline const VectorReference &
1391 VectorReference::operator-=(
const TrilinosScalar &value)
const 1393 TrilinosScalar new_value = -value;
1394 vector.
add(1, &index, &new_value);
1400 inline const VectorReference &
1401 VectorReference::operator*=(
const TrilinosScalar &value)
const 1403 TrilinosScalar new_value =
static_cast<TrilinosScalar
>(*this) * value;
1404 vector.
set(1, &index, &new_value);
1410 inline const VectorReference &
1411 VectorReference::operator/=(
const TrilinosScalar &value)
const 1413 TrilinosScalar new_value =
static_cast<TrilinosScalar
>(*this) / value;
1414 vector.
set(1, &index, &new_value);
1424 std::pair<size_type, size_type> range = local_range();
1426 return ((index >= range.first) && (index < range.second));
1434 Assert(owned_elements.size() == size(),
1436 "The locally owned elements have not been properly initialized!" 1437 " This happens for example if this object has been initialized" 1438 " with exactly one overlapping IndexSet."));
1439 return owned_elements;
1445 Vector::has_ghost_elements()
const 1458 inline internal::VectorReference
1461 return internal::VectorReference(*
this, index);
1468 return operator()(index);
1475 return operator()(index);
1482 std::vector<TrilinosScalar> & values)
const 1484 for (size_type i = 0; i < indices.size(); ++i)
1485 values[i] =
operator()(indices[i]);
1490 template <
typename ForwardIterator,
typename OutputIterator>
1493 const ForwardIterator indices_end,
1494 OutputIterator values_begin)
const 1496 while (indices_begin != indices_end)
1498 *values_begin = operator()(*indices_begin);
1506 inline Vector::iterator
1509 return (*vector)[0];
1514 inline Vector::iterator
1517 return (*vector)[0] + local_size();
1522 inline Vector::const_iterator
1525 return (*vector)[0];
1530 inline Vector::const_iterator
1533 return (*vector)[0] + local_size();
1539 Vector::set(
const std::vector<size_type> & indices,
1540 const std::vector<TrilinosScalar> &values)
1546 Assert(indices.size() == values.size(),
1549 set(indices.size(), indices.data(), values.data());
1555 Vector::set(
const std::vector<size_type> & indices,
1556 const ::Vector<TrilinosScalar> &values)
1562 Assert(indices.size() == values.size(),
1565 set(indices.size(), indices.data(), values.begin());
1571 Vector::set(
const size_type n_elements,
1572 const size_type * indices,
1573 const TrilinosScalar *values)
1579 if (last_action == Add)
1581 const int ierr = vector->GlobalAssemble(Add);
1585 if (last_action != Insert)
1586 last_action = Insert;
1588 for (size_type i = 0; i < n_elements; ++i)
1590 const size_type row = indices[i];
1591 const TrilinosWrappers::types::int_type local_row = vector->Map().LID(
1592 static_cast<TrilinosWrappers::types::int_type>(row));
1593 if (local_row != -1)
1594 (*vector)[0][local_row] = values[i];
1597 const int ierr = vector->ReplaceGlobalValues(
1599 (
const TrilinosWrappers::types::int_type *)(&row),
1615 Vector::add(
const std::vector<size_type> & indices,
1616 const std::vector<TrilinosScalar> &values)
1621 Assert(indices.size() == values.size(),
1624 add(indices.size(), indices.data(), values.data());
1630 Vector::add(
const std::vector<size_type> & indices,
1631 const ::Vector<TrilinosScalar> &values)
1636 Assert(indices.size() == values.size(),
1639 add(indices.size(), indices.data(), values.begin());
1646 const size_type * indices,
1647 const TrilinosScalar *values)
1653 if (last_action != Add)
1655 if (last_action == Insert)
1657 const int ierr = vector->GlobalAssemble(Insert);
1663 for (size_type i = 0; i < n_elements; ++i)
1665 const size_type row = indices[i];
1666 const TrilinosWrappers::types::int_type local_row = vector->Map().LID(
1667 static_cast<TrilinosWrappers::types::int_type>(row));
1668 if (local_row != -1)
1669 (*vector)[0][local_row] += values[i];
1670 else if (nonlocal_vector.get() ==
nullptr)
1672 const int ierr = vector->SumIntoGlobalValues(
1674 (
const TrilinosWrappers::types::int_type *)(&row),
1683 const TrilinosWrappers::types::int_type my_row =
1684 nonlocal_vector->Map().LID(
1685 static_cast<TrilinosWrappers::types::int_type>(row));
1688 "Attempted to write into off-processor vector entry " 1689 "that has not be specified as being writable upon " 1691 (*nonlocal_vector)[0][my_row] += values[i];
1699 inline Vector::size_type
1702 # ifndef DEAL_II_WITH_64BIT_INDICES 1703 return (size_type)(vector->Map().MaxAllGID() + 1 -
1704 vector->Map().MinAllGID());
1706 return (size_type)(vector->Map().MaxAllGID64() + 1 -
1707 vector->Map().MinAllGID64());
1713 inline Vector::size_type
1714 Vector::local_size()
const 1716 return (size_type)vector->Map().NumMyElements();
1721 inline std::pair<Vector::size_type, Vector::size_type>
1722 Vector::local_range()
const 1724 # ifndef DEAL_II_WITH_64BIT_INDICES 1725 const TrilinosWrappers::types::int_type begin = vector->Map().MinMyGID();
1726 const TrilinosWrappers::types::int_type end =
1727 vector->Map().MaxMyGID() + 1;
1729 const TrilinosWrappers::types::int_type begin =
1730 vector->Map().MinMyGID64();
1731 const TrilinosWrappers::types::int_type end =
1732 vector->Map().MaxMyGID64() + 1;
1736 end - begin == vector->Map().NumMyElements(),
1738 "This function only makes sense if the elements that this " 1739 "vector stores on the current processor form a contiguous range. " 1740 "This does not appear to be the case for the current vector."));
1742 return std::make_pair(begin, end);
1750 ExcDifferentParallelPartitioning());
1753 TrilinosScalar result;
1755 const int ierr = vector->Dot(*(vec.
vector), &result);
1763 inline Vector::real_type
1766 const TrilinosScalar d = l2_norm();
1772 inline TrilinosScalar
1777 TrilinosScalar mean;
1778 const int ierr = vector->MeanValue(&mean);
1786 inline TrilinosScalar
1789 TrilinosScalar min_value;
1790 const int ierr = vector->MinValue(&min_value);
1798 inline TrilinosScalar
1801 TrilinosScalar max_value;
1802 const int ierr = vector->MaxValue(&max_value);
1810 inline Vector::real_type
1816 const int ierr = vector->Norm1(&d);
1824 inline Vector::real_type
1830 const int ierr = vector->Norm2(&d);
1838 inline Vector::real_type
1843 TrilinosScalar norm = 0;
1844 TrilinosScalar sum = 0;
1845 const size_type n_local = local_size();
1849 for (size_type i = 0; i < n_local; i++)
1850 sum += std::pow(std::fabs((*vector)[0][i]), p);
1852 norm = std::pow(sum, static_cast<TrilinosScalar>(1. / p));
1859 inline Vector::real_type
1868 const int ierr = vector->NormInf(&d);
1876 inline TrilinosScalar
1897 const int ierr = vector->Scale(a);
1910 const TrilinosScalar factor = 1. / a;
1914 const int ierr = vector->Scale(factor);
1927 ExcDifferentParallelPartitioning());
1929 const int ierr = vector->Update(1.0, *(v.
vector), 1.0);
1942 ExcDifferentParallelPartitioning());
1944 const int ierr = vector->Update(-1.0, *(v.
vector), 1.0);
1960 size_type n_local = local_size();
1961 for (size_type i = 0; i < n_local; i++)
1962 (*vector)[0][i] += s;
1978 const int ierr = vector->Update(a, *(v.
vector), 1.);
1987 const TrilinosScalar b,
2001 const int ierr = vector->Update(a, *(v.
vector), b, *(w.
vector), 1.);
2022 Assert(this->vector->Map().SameAs(v.
vector->Map()) ==
true,
2023 ExcDifferentParallelPartitioning());
2024 const int ierr = vector->Update(1., *(v.
vector), s);
2038 const TrilinosScalar a,
2052 Assert(this->vector->Map().SameAs(v.
vector->Map()) ==
true,
2053 ExcDifferentParallelPartitioning());
2054 const int ierr = vector->Update(a, *(v.
vector), s);
2062 this->add(tmp,
true);
2077 const int ierr = vector->Multiply(1.0, *(factors.
vector), *vector, 0.0);
2092 if (vector->Map().SameAs(v.
vector->Map()) ==
false)
2094 this->sadd(0., a, v);
2099 int ierr = vector->Update(a, *v.
vector, 0.0);
2108 inline const Epetra_MultiVector &
2109 Vector::trilinos_vector()
const 2111 return static_cast<const Epetra_MultiVector &
>(*vector);
2116 inline Epetra_FEVector &
2117 Vector::trilinos_vector()
2124 inline const Epetra_Map &
2125 Vector::vector_partitioner()
const 2127 return static_cast<const Epetra_Map &
>(vector->Map());
2132 inline const MPI_Comm &
2133 Vector::get_mpi_communicator()
const 2135 static MPI_Comm comm;
2137 # ifdef DEAL_II_WITH_MPI 2139 const Epetra_MpiComm *mpi_comm =
2140 dynamic_cast<const Epetra_MpiComm *
>(&vector->Map().Comm());
2141 comm = mpi_comm->Comm();
2145 comm = MPI_COMM_SELF;
2152 template <
typename number>
2154 const ::Vector<number> &v,
2155 const MPI_Comm & communicator)
2159 owned_elements = parallel_partitioner;
2169 int ierr = vector->PutScalar(s);
2172 if (nonlocal_vector.get() !=
nullptr)
2174 ierr = nonlocal_vector->PutScalar(0.);
2191 namespace LinearOperatorImplementation
2204 template <
typename Matrix>
2206 reinit_range_vector(
const Matrix & matrix,
2208 bool omit_zeroing_entries)
2210 v.
reinit(matrix.locally_owned_range_indices(),
2211 matrix.get_mpi_communicator(),
2212 omit_zeroing_entries);
2215 template <
typename Matrix>
2217 reinit_domain_vector(
const Matrix & matrix,
2219 bool omit_zeroing_entries)
2221 v.
reinit(matrix.locally_owned_domain_indices(),
2222 matrix.get_mpi_communicator(),
2223 omit_zeroing_entries);
2242 DEAL_II_NAMESPACE_CLOSE
2244 #endif // DEAL_II_WITH_TRILINOS 2248 #endif // dealii_trilinos_vector_h real_type lp_norm(const real_type p) const
static::ExceptionBase & ExcTrilinosError(int arg1)
real_type norm_sqr() const
IndexSet locally_owned_elements() const
real_type l2_norm() const
Number add_and_dot(const Number a, const Vector< Number > &V, const Vector< Number > &W)
Number mean_value() const
void sadd(const Number s, const Vector< Number > &V)
void reinit(const Vector &v, const bool omit_zeroing_entries=false, const bool allow_different_maps=false)
void add(const std::vector< size_type > &indices, const std::vector< TrilinosScalar > &values)
void equ(const Number a, const Vector< Number > &u)
bool in_local_range(const size_type global_index) const
#define AssertThrow(cond, exc)
void update_ghost_values() const
Vector< Number > & operator=(const Number s)
unsigned long long int global_dof_index
Number operator*(const Vector< Number2 > &V) const
real_type linfty_norm() const
void add(const std::vector< size_type > &indices, const std::vector< OtherNumber > &values)
static::ExceptionBase & ExcMessage(std::string arg1)
void scale(const Vector< Number > &scaling_factors)
void set(const std::vector< size_type > &indices, const std::vector< TrilinosScalar > &values)
#define DeclException1(Exception1, type1, outsequence)
Vector< Number > & operator+=(const Vector< Number > &V)
#define Assert(cond, exc)
static::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
std::unique_ptr< Epetra_FEVector > vector
#define DeclException0(Exception0)
Number operator[](const size_type i) const
Vector< Number > & operator-=(const Vector< Number > &V)
Vector< Number > & operator*=(const Number factor)
bool has_ghost_elements() const
real_type l1_norm() const
Epetra_Map make_trilinos_map(const MPI_Comm &communicator=MPI_COMM_WORLD, const bool overlapping=false) const
types::global_dof_index size_type
static::ExceptionBase & ExcGhostsPresent()
void swap(Vector< Number > &u, Vector< Number > &v)
Vector< Number > & operator/=(const Number factor)
TrilinosScalar value_type
void extract_subvector_to(const std::vector< size_type > &indices, std::vector< OtherNumber > &values) const
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence)
size_type local_size() const
Number operator()(const size_type i) const
#define AssertIsFinite(number)