Debian Codegraph @

include/deal.II/lac/trilinos_tpetra_vector.templates.h

raw
1 // ------------------------------------------------------------------------
2 //
3 // SPDX-License-Identifier: LGPL-2.1-or-later
4 // Copyright (C) 2018 - 2025 by the deal.II authors
5 //
6 // This file is part of the deal.II library.
7 //
8 // Part of the source code is dual licensed under Apache-2.0 WITH
9 // LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10 // governing the source code and code contributions can be found in
11 // LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12 //
13 // ------------------------------------------------------------------------
14
15 #ifndef dealii_trilinos_tpetra_vector_templates_h
16 #define dealii_trilinos_tpetra_vector_templates_h
17
18 #include <deal.II/base/config.h>
19
20 #include <deal.II/base/mpi.h>
21
22 #include <deal.II/lac/trilinos_tpetra_vector.h>
23
24 #ifdef DEAL_II_TRILINOS_WITH_TPETRA
25
26 # include <deal.II/base/index_set.h>
27 # include <deal.II/base/trilinos_utilities.h>
28
29 # include <deal.II/lac/read_write_vector.h>
30
31 # include <boost/io/ios_state.hpp>
32
33 # include <Teuchos_DefaultMpiComm.hpp>
34 # include <Tpetra_Import_def.hpp>
35 # include <Tpetra_Map_def.hpp>
36
37 # include <memory>
38
39
40 DEAL_II_NAMESPACE_OPEN
41
42 namespace LinearAlgebra
43 {
44 namespace TpetraWrappers
45 {
46 namespace internal
47 {
48 template <typename Number, typename MemorySpace>
49 VectorReference<Number, MemorySpace>::operator Number() const
50 {
51 // Get the local index
52 const TrilinosWrappers::types::int_type local_index =
53 vector.vector->getMap()->getLocalElement(
54 static_cast<TrilinosWrappers::types::int_type>(index));
55
56 # if DEAL_II_TRILINOS_VERSION_GTE(14, 0, 0)
57 Assert(
58 (local_index != Teuchos::OrdinalTraits<int>::invalid()),
59 (typename Vector<Number, MemorySpace>::ExcAccessToNonLocalElement(
60 index,
61 vector.vector->getMap()->getLocalNumElements(),
62 vector.vector->getMap()->getMinLocalIndex(),
63 vector.vector->getMap()->getMaxLocalIndex())));
64 # else
65 Assert(
66 (local_index != Teuchos::OrdinalTraits<int>::invalid()),
67 (typename Vector<Number, MemorySpace>::ExcAccessToNonLocalElement(
68 index,
69 vector.vector->getMap()->getNodeNumElements(),
70 vector.vector->getMap()->getMinLocalIndex(),
71 vector.vector->getMap()->getMaxLocalIndex())));
72 # endif
73 return vector.vector->getData()[local_index];
74 }
75 } // namespace internal
76
77
78
79 template <typename Number, typename MemorySpace>
80 Vector<Number, MemorySpace>::Vector()
81 : compressed(true)
82 , has_ghost(false)
83 , vector(Utilities::Trilinos::internal::make_rcp<
84 TpetraTypes::VectorType<Number, MemorySpace>>(
85 Utilities::Trilinos::internal::make_rcp<TpetraTypes::MapType<
86 MemorySpace>>(0, 0, Utilities::Trilinos::tpetra_comm_self())))
87 {}
88
89
90
91 template <typename Number, typename MemorySpace>
92 Vector<Number, MemorySpace>::Vector(const Vector<Number, MemorySpace> &V)
93 : compressed(V.compressed)
94 , has_ghost(V.has_ghost)
95 , vector(Utilities::Trilinos::internal::make_rcp<
96 TpetraTypes::VectorType<Number, MemorySpace>>(*V.vector,
97 Teuchos::Copy))
98 {
99 if (!V.nonlocal_vector.is_null())
100 nonlocal_vector = Utilities::Trilinos::internal::make_rcp<
101 TpetraTypes::VectorType<Number, MemorySpace>>(*V.nonlocal_vector,
102 Teuchos::Copy);
103 }
104
105
106
107 template <typename Number, typename MemorySpace>
108 Vector<Number, MemorySpace>::Vector(
109 const Teuchos::RCP<TpetraTypes::VectorType<Number, MemorySpace>> V)
110 : compressed(true)
111 , has_ghost(V->getMap()->isOneToOne() == false)
112 , vector(V)
113 {}
114
115
116
117 template <typename Number, typename MemorySpace>
118 Vector<Number, MemorySpace>::Vector(const IndexSet &parallel_partitioner,
119 const MPI_Comm communicator)
120 : compressed(true)
121 , has_ghost(false)
122 , vector(Utilities::Trilinos::internal::make_rcp<
123 TpetraTypes::VectorType<Number, MemorySpace>>(
124 parallel_partitioner.make_tpetra_map_rcp<
125 TpetraTypes::NodeType<MemorySpace>>(communicator, true)))
126 {}
127
128
129
130 template <typename Number, typename MemorySpace>
131 Vector<Number, MemorySpace>::Vector(const IndexSet &locally_owned_entries,
132 const IndexSet &ghost_entries,
133 const MPI_Comm communicator,
134 const bool vector_writable)
135 {
136 if (!vector_writable)
137 {
138 IndexSet parallel_partitioner = locally_owned_entries;
139 parallel_partitioner.add_indices(ghost_entries);
140
141 vector = Utilities::Trilinos::internal::make_rcp<
142 TpetraTypes::VectorType<Number, MemorySpace>>(
143 parallel_partitioner
144 .template make_tpetra_map_rcp<TpetraTypes::NodeType<MemorySpace>>(
145 communicator, true));
146
147 compressed = true;
148 }
149 else
150 {
151 Teuchos::RCP<TpetraTypes::MapType<MemorySpace>> map =
152 locally_owned_entries
153 .template make_tpetra_map_rcp<TpetraTypes::NodeType<MemorySpace>>(
154 communicator, false);
155 vector = Utilities::Trilinos::internal::make_rcp<
156 TpetraTypes::VectorType<Number, MemorySpace>>(map);
157
158 IndexSet nonlocal_entries(ghost_entries);
159 nonlocal_entries.subtract_set(locally_owned_entries);
160 nonlocal_vector = Utilities::Trilinos::internal::make_rcp<
161 TpetraTypes::VectorType<Number, MemorySpace>>(
162 nonlocal_entries
163 .template make_tpetra_map_rcp<TpetraTypes::NodeType<MemorySpace>>(
164 communicator, true));
165
166 compressed = false;
167 }
168
169 has_ghost = (vector->getMap()->isOneToOne() == false);
170
171 if constexpr (running_in_debug_mode())
172 {
173 MPI_Comm comm = Utilities::Trilinos::teuchos_comm_to_mpi_comm(
174 vector->getMap()->getComm());
175 const size_type n_elements_global =
176 Utilities::MPI::sum(vector->getLocalLength(), comm);
177 Assert(has_ghost || n_elements_global == size(), ExcInternalError());
178 }
179 }
180
181
182
183 template <typename Number, typename MemorySpace>
184 void
185 Vector<Number, MemorySpace>::clear()
186 {
187 vector = Utilities::Trilinos::internal::make_rcp<
188 TpetraTypes::VectorType<Number, MemorySpace>>(
189 Utilities::Trilinos::internal::make_rcp<
190 TpetraTypes::MapType<MemorySpace>>(
191 0, 0, Utilities::Trilinos::tpetra_comm_self()));
192 has_ghost = false;
193 compressed = true;
194 nonlocal_vector.reset();
195 }
196
197
198
199 template <typename Number, typename MemorySpace>
200 void
201 Vector<Number, MemorySpace>::reinit(const IndexSet &parallel_partitioner,
202 const MPI_Comm communicator,
203 const bool /*omit_zeroing_entries*/)
204 {
205 vector.reset();
206 nonlocal_vector.reset();
207
208 compressed = true;
209 has_ghost = false;
210 vector = Utilities::Trilinos::internal::make_rcp<
211 TpetraTypes::VectorType<Number, MemorySpace>>(
212 parallel_partitioner
213 .template make_tpetra_map_rcp<TpetraTypes::NodeType<MemorySpace>>(
214 communicator, true));
215 }
216
217
218
219 template <typename Number, typename MemorySpace>
220 void
221 Vector<Number, MemorySpace>::reinit(const IndexSet &locally_owned_entries,
222 const IndexSet &ghost_entries,
223 const MPI_Comm communicator,
224 const bool vector_writable)
225 {
226 // release memory before reallocation
227 nonlocal_vector.reset();
228
229 if (!vector_writable)
230 {
231 vector.reset();
232
233 IndexSet parallel_partitioner = locally_owned_entries;
234 parallel_partitioner.add_indices(ghost_entries);
235
236 vector = Utilities::Trilinos::internal::make_rcp<
237 TpetraTypes::VectorType<Number, MemorySpace>>(
238 parallel_partitioner
239 .template make_tpetra_map_rcp<TpetraTypes::NodeType<MemorySpace>>(
240 communicator, true));
241
242 compressed = true;
243 }
244 else
245 {
246 Teuchos::RCP<TpetraTypes::MapType<MemorySpace>> map =
247 locally_owned_entries
248 .template make_tpetra_map_rcp<TpetraTypes::NodeType<MemorySpace>>(
249 communicator, false);
250
251 if (!vector->getMap()->isSameAs(*map))
252 {
253 vector.reset();
254 vector = Utilities::Trilinos::internal::make_rcp<
255 TpetraTypes::VectorType<Number, MemorySpace>>(map);
256 }
257 else
258 vector->putScalar(0);
259
260 IndexSet nonlocal_entries(ghost_entries);
261 nonlocal_entries.subtract_set(locally_owned_entries);
262
263 nonlocal_vector = Utilities::Trilinos::internal::make_rcp<
264 TpetraTypes::VectorType<Number, MemorySpace>>(
265 nonlocal_entries
266 .template make_tpetra_map_rcp<TpetraTypes::NodeType<MemorySpace>>(
267 communicator, true));
268
269 compressed = false;
270 }
271
272 has_ghost = (vector->getMap()->isOneToOne() == false);
273 }
274
275
276
277 template <typename Number, typename MemorySpace>
278 void
279 Vector<Number, MemorySpace>::reinit(const Vector<Number, MemorySpace> &V,
280 const bool omit_zeroing_entries)
281 {
282 reinit(V.locally_owned_elements(),
283 V.get_mpi_communicator(),
284 omit_zeroing_entries);
285 }
286
287
288
289 template <typename Number, typename MemorySpace>
290 void
291 Vector<Number, MemorySpace>::extract_subvector_to(
292 const ArrayView<const types::global_dof_index> &indices,
293 const ArrayView<Number> &elements) const
294 {
295 AssertDimension(indices.size(), elements.size());
296
297 auto vector_2d = vector->template getLocalView<Kokkos::HostSpace>(
298 Tpetra::Access::ReadOnly);
299 auto vector_1d = Kokkos::subview(vector_2d, Kokkos::ALL(), 0);
300
301 for (unsigned int i = 0; i < indices.size(); ++i)
302 {
303 AssertIndexRange(indices[i], size());
304 const size_type row = indices[i];
305 TrilinosWrappers::types::int_type local_row =
306 vector->getMap()->getLocalElement(row);
307
308
309 # if DEAL_II_TRILINOS_VERSION_GTE(14, 0, 0)
310 Assert(
311 local_row != Teuchos::OrdinalTraits<int>::invalid(),
312 ExcAccessToNonLocalElement(row,
313 vector->getMap()->getLocalNumElements(),
314 vector->getMap()->getMinLocalIndex(),
315 vector->getMap()->getMaxLocalIndex()));
316 # else
317 Assert(
318 local_row != Teuchos::OrdinalTraits<int>::invalid(),
319 ExcAccessToNonLocalElement(row,
320 vector->getMap()->getNodeNumElements(),
321 vector->getMap()->getMinLocalIndex(),
322 vector->getMap()->getMaxLocalIndex()));
323
324 # endif
325
326 if (local_row != Teuchos::OrdinalTraits<int>::invalid())
327 elements[i] = vector_1d(local_row);
328 }
329 }
330
331
332
333 template <typename Number, typename MemorySpace>
334 Vector<Number, MemorySpace> &
335 Vector<Number, MemorySpace>::operator=(const Vector<Number, MemorySpace> &V)
336 {
337 // Distinguish three cases:
338 // - First case: both vectors have the same layout.
339 // - Second case: both vectors have the same size but different layout.
340 // - Third case: the vectors have different size.
341
342 AssertThrow(V.compressed,
343 ExcMessage("Cannot copy-assign from a vector that has not "
344 "been compressed. Please call compress() on the "
345 "source vector before using operator=()."));
346
347 if (vector->getMap()->isSameAs(*V.vector->getMap()))
348 {
349 // Create a read-only Kokkos view from the source vector
350 auto source_vector_2d =
351 V.vector->template getLocalView<Kokkos::HostSpace>(
352 Tpetra::Access::ReadOnly);
353
354 auto source_vector_1d =
355 Kokkos::subview(source_vector_2d, Kokkos::ALL(), 0);
356
357 // Create a read/write Kokkos view from the target vector
358 auto target_vector_2d =
359 vector->template getLocalView<Kokkos::HostSpace>(
360 Tpetra::Access::ReadWrite);
361 auto target_vector_1d =
362 Kokkos::subview(target_vector_2d, Kokkos::ALL(), 0);
363
364 // Copy the data
365 Kokkos::deep_copy(target_vector_1d, source_vector_1d);
366 }
367 else if (size() == V.size())
368 {
369 // We expect that at least one vector has a one-to-one map, otherwise
370 // we can neither call Import nor Export.
371 if (V.vector->getMap()->isOneToOne())
372 {
373 Teuchos::RCP<const TpetraTypes::ImportType<MemorySpace>>
374 importer =
375 Tpetra::createImport(V.vector->getMap(), vector->getMap());
376
377 // Since we are distributing the vector from a one-to-one map
378 // we can always use the VectorOperation::insert / Tpetra::INSERT
379 // here.
380 vector->doImport(*V.vector, *importer, Tpetra::INSERT);
381 }
382 else if (vector->getMap()->isOneToOne())
383 {
384 Teuchos::RCP<const TpetraTypes::ExportType<MemorySpace>>
385 exporter =
386 Tpetra::createExport(V.vector->getMap(), vector->getMap());
387
388 vector->doExport(*V.vector, *exporter, Tpetra::INSERT);
389 }
390 else
391 {
392 Assert(false,
393 ExcMessage(
394 "You are trying to map one vector distributed "
395 "between processors, where some elements belong "
396 "to multiple processors, onto another distribution "
397 "pattern, where some elements belong to multiple "
398 "processors. It is unclear how to deal with elements "
399 "in the vector belonging to multiple processors. "
400 "Therefore, compress() must be called on this "
401 "vector first."));
402 }
403 }
404 else
405 {
406 vector.reset();
407 vector = Utilities::Trilinos::internal::make_rcp<
408 TpetraTypes::VectorType<Number, MemorySpace>>(*V.vector,
409 Teuchos::Copy);
410
411 compressed = V.compressed;
412 has_ghost = V.has_ghost;
413 source_stored_elements = V.source_stored_elements;
414 tpetra_comm_pattern = V.tpetra_comm_pattern;
415 }
416
417 return *this;
418 }
419
420
421
422 template <typename Number, typename MemorySpace>
423 template <typename OtherNumber>
424 Vector<Number, MemorySpace> &
425 Vector<Number, MemorySpace>::operator=(const dealii::Vector<OtherNumber> &V)
426 {
427 static_assert(
428 std::is_same<Number, OtherNumber>::value,
429 "TpetraWrappers::Vector and dealii::Vector must use the same number type here.");
430
431 vector.reset();
432 nonlocal_vector.reset();
433
434 Teuchos::Array<OtherNumber> vector_data(V.begin(), V.end());
435 vector = Utilities::Trilinos::internal::make_rcp<
436 TpetraTypes::VectorType<Number, MemorySpace>>(
437 V.locally_owned_elements()
438 .template make_tpetra_map_rcp<TpetraTypes::NodeType<MemorySpace>>(),
439 vector_data);
440
441 has_ghost = false;
442 compressed = true;
443
444 return *this;
445 }
446
447
448
449 template <typename Number, typename MemorySpace>
450 Vector<Number, MemorySpace> &
451 Vector<Number, MemorySpace>::operator=(const Number s)
452 {
453 Assert(s == Number(0.0),
454 ExcMessage("Only 0 can be assigned to a vector."));
455
456 // As checked above, we are only allowed to use d==0.0, so pass
457 // a constant zero (instead of a run-time value 'd' that *happens* to
458 // have a zero value) to the underlying class in hopes that the compiler
459 // can optimize this somehow.
460 vector->putScalar(/*s=*/0.0);
461
462 if (!nonlocal_vector.is_null())
463 nonlocal_vector->putScalar(/*s=*/0.0);
464
465 return *this;
466 }
467
468
469
470 template <typename Number, typename MemorySpace>
471 void
472 Vector<Number, MemorySpace>::import_elements(
473 const ReadWriteVector<Number> &V,
474 VectorOperation::values operation,
475 const Teuchos::RCP<const Utilities::MPI::CommunicationPatternBase>
476 &communication_pattern)
477 {
478 // If no communication pattern is given, create one. Otherwise, use the
479 // one given.
480 if (communication_pattern.is_null())
481 {
482 // The first time import is called, a communication pattern is
483 // created. Check if the communication pattern already exists and if
484 // it can be reused.
485 if ((source_stored_elements.size() !=
486 V.get_stored_elements().size()) ||
487 (source_stored_elements != V.get_stored_elements()))
488 {
489 create_tpetra_comm_pattern(
490 V.get_stored_elements(),
491 Utilities::Trilinos::teuchos_comm_to_mpi_comm(
492 vector->getMap()->getComm()));
493 }
494 }
495 else
496 {
497 tpetra_comm_pattern = Teuchos::rcp_dynamic_cast<
498 const TpetraWrappers::CommunicationPattern<MemorySpace>>(
499 communication_pattern);
500
501 AssertThrow(
502 !tpetra_comm_pattern.is_null(),
503 ExcMessage("The communication pattern is not of type "
504 "LinearAlgebra::TpetraWrappers::CommunicationPattern."));
505 }
506
507 Teuchos::RCP<const TpetraTypes::ExportType<MemorySpace>> tpetra_export =
508 tpetra_comm_pattern->get_tpetra_export_rcp();
509
510 TpetraTypes::VectorType<Number, MemorySpace> source_vector(
511 tpetra_export->getSourceMap());
512
513 {
514 auto x_2d = source_vector.template getLocalView<Kokkos::HostSpace>(
515 Tpetra::Access::ReadWrite);
516 auto x_1d = Kokkos::subview(x_2d, Kokkos::ALL(), 0);
517
518 const size_t localLength = source_vector.getLocalLength();
519 auto values_it = V.begin();
520 for (size_t k = 0; k < localLength; ++k)
521 x_1d(k) = *values_it++;
522 }
523 Tpetra::CombineMode tpetra_operation = Tpetra::ZERO;
524 if (operation == VectorOperation::insert)
525 tpetra_operation = Tpetra::INSERT;
526 else if (operation == VectorOperation::add)
527 tpetra_operation = Tpetra::ADD;
528 else
529 DEAL_II_NOT_IMPLEMENTED();
530
531 vector->doExport(source_vector, *tpetra_export, tpetra_operation);
532 }
533
534
535
536 template <typename Number, typename MemorySpace>
537 void
538 Vector<Number, MemorySpace>::import_elements(
539 const ReadWriteVector<Number> &V,
540 VectorOperation::values operation,
541 const std::shared_ptr<const Utilities::MPI::CommunicationPatternBase> &)
542 {
543 import_elements(V, operation);
544 }
545
546
547
548 template <typename Number, typename MemorySpace>
549 void
550 Vector<Number, MemorySpace>::import_elements(
551 const ReadWriteVector<Number> &V,
552 VectorOperation::values operation)
553 {
554 // Create an empty CommunicationPattern
555 const Teuchos::RCP<const Utilities::MPI::CommunicationPatternBase>
556 communication_pattern_empty;
557
558 import_elements(V, operation, communication_pattern_empty);
559 }
560
561
562
563 template <typename Number, typename MemorySpace>
564 Vector<Number, MemorySpace> &
565 Vector<Number, MemorySpace>::operator*=(const Number factor)
566 {
567 AssertIsFinite(factor);
568 vector->scale(factor);
569
570 return *this;
571 }
572
573
574
575 template <typename Number, typename MemorySpace>
576 Vector<Number, MemorySpace> &
577 Vector<Number, MemorySpace>::operator/=(const Number factor)
578 {
579 AssertIsFinite(factor);
580 Assert(factor != Number(0.), ExcZero());
581 *this *= Number(1.) / factor;
582
583 return *this;
584 }
585
586
587
588 template <typename Number, typename MemorySpace>
589 Vector<Number, MemorySpace> &
590 Vector<Number, MemorySpace>::operator+=(
591 const Vector<Number, MemorySpace> &V)
592 {
593 // If the maps are the same we can update right away.
594 if (vector->getMap()->isSameAs(*(V.trilinos_vector().getMap())))
595 {
596 vector->update(1., V.trilinos_vector(), 1.);
597 }
598 else
599 {
600 Assert(this->size() == V.size(),
601 ExcDimensionMismatch(this->size(), V.size()));
602
603 // TODO: Tpetra doesn't have a combine mode that also updates local
604 // elements, maybe there is a better workaround.
605 Tpetra::Vector<Number,
606 int,
607 types::signed_global_dof_index,
608 TpetraTypes::NodeType<MemorySpace>>
609 dummy(vector->getMap(), false);
610 TpetraTypes::ImportType<MemorySpace> data_exchange(
611 V.trilinos_vector().getMap(), dummy.getMap());
612 dummy.doImport(V.trilinos_vector(), data_exchange, Tpetra::INSERT);
613
614 vector->update(1.0, dummy, 1.0);
615 }
616
617 return *this;
618 }
619
620
621
622 template <typename Number, typename MemorySpace>
623 Vector<Number, MemorySpace> &
624 Vector<Number, MemorySpace>::operator-=(
625 const Vector<Number, MemorySpace> &V)
626 {
627 this->add(-1., V);
628
629 return *this;
630 }
631
632
633
634 template <typename Number, typename MemorySpace>
635 Number
636 Vector<Number, MemorySpace>::operator*(
637 const Vector<Number, MemorySpace> &V) const
638 {
639 Assert(this->size() == V.size(),
640 ExcDimensionMismatch(this->size(), V.size()));
641 Assert(vector->getMap()->isSameAs(*V.trilinos_vector().getMap()),
642 ExcDifferentParallelPartitioning());
643 Assert(!has_ghost_elements(), ExcGhostsPresent());
644
645 return vector->dot(V.trilinos_vector());
646 }
647
648
649
650 template <typename Number, typename MemorySpace>
651 Number
652 Vector<Number, MemorySpace>::operator()(const size_type index) const
653 {
654 // Get the local index
655 const TrilinosWrappers::types::int_type local_index =
656 vector->getMap()->getLocalElement(
657 static_cast<TrilinosWrappers::types::int_type>(index));
658
659 Number value = 0.0;
660
661 // If the element is not present on the current processor, we can't
662 // continue. This is the main difference to the el() function.
663 if (local_index == Teuchos::OrdinalTraits<int>::invalid())
664 {
665 # if DEAL_II_TRILINOS_VERSION_GTE(14, 0, 0)
666 Assert(
667 false,
668 ExcAccessToNonLocalElement(index,
669 vector->getMap()->getLocalNumElements(),
670 vector->getMap()->getMinLocalIndex(),
671 vector->getMap()->getMaxLocalIndex()));
672 # else
673 Assert(
674 false,
675 ExcAccessToNonLocalElement(index,
676 vector->getMap()->getNodeNumElements(),
677 vector->getMap()->getMinLocalIndex(),
678 vector->getMap()->getMaxLocalIndex()));
679 # endif
680 }
681 else
682 value = vector->getData()[local_index];
683
684 return value;
685 }
686
687
688
689 template <typename Number, typename MemorySpace>
690 void
691 Vector<Number, MemorySpace>::add(const Number a)
692 {
693 AssertIsFinite(a);
694
695 // if we have ghost values, do not allow
696 // writing to this vector at all.
697 Assert(!has_ghost_elements(), ExcGhostsPresent());
698
699 auto vector_2d = vector->template getLocalView<Kokkos::HostSpace>(
700 Tpetra::Access::ReadWrite);
701 auto vector_1d = Kokkos::subview(vector_2d, Kokkos::ALL(), 0);
702
703 const size_t localLength = vector->getLocalLength();
704 for (size_t k = 0; k < localLength; ++k)
705 {
706 vector_1d(k) += a;
707 }
708 }
709
710
711
712 template <typename Number, typename MemorySpace>
713 void
714 Vector<Number, MemorySpace>::add(const Number a,
715 const Vector<Number, MemorySpace> &V)
716 {
717 AssertIsFinite(a);
718
719 Assert(vector->getMap()->isSameAs(*(V.trilinos_vector().getMap())),
720 ExcDifferentParallelPartitioning());
721
722 // if we have ghost values, do not allow
723 // writing to this vector at all.
724 Assert(!has_ghost_elements(), ExcGhostsPresent());
725
726 vector->update(a, V.trilinos_vector(), 1.);
727 }
728
729
730
731 template <typename Number, typename MemorySpace>
732 void
733 Vector<Number, MemorySpace>::add(const Number a,
734 const Vector<Number, MemorySpace> &V,
735 const Number b,
736 const Vector<Number, MemorySpace> &W)
737 {
738 AssertIsFinite(a);
739 AssertIsFinite(b);
740
741 Assert(vector->getMap()->isSameAs(*(V.trilinos_vector().getMap())),
742 ExcDifferentParallelPartitioning());
743 Assert(vector->getMap()->isSameAs(*(W.trilinos_vector().getMap())),
744 ExcDifferentParallelPartitioning());
745
746 // if we have ghost values, do not allow
747 // writing to this vector at all.
748 Assert(!has_ghost_elements(), ExcGhostsPresent());
749
750 vector->update(a, V.trilinos_vector(), b, W.trilinos_vector(), 1.);
751 }
752
753
754
755 template <typename Number, typename MemorySpace>
756 void
757 Vector<Number, MemorySpace>::sadd(const Number s,
758 const Number a,
759 const Vector<Number, MemorySpace> &V)
760 {
761 AssertIsFinite(s);
762 AssertIsFinite(a);
763
764 // if we have ghost values, do not allow
765 // writing to this vector at all.
766 Assert(!has_ghost_elements(), ExcGhostsPresent());
767
768 *this *= s;
769
770 Vector<Number, MemorySpace> tmp(V);
771 tmp *= a;
772 *this += tmp;
773 }
774
775
776
777 template <typename Number, typename MemorySpace>
778 void
779 Vector<Number, MemorySpace>::scale(
780 const Vector<Number, MemorySpace> &scaling_factors)
781 {
782 Assert(vector->getMap()->isSameAs(
783 *(scaling_factors.trilinos_vector().getMap())),
784 ExcDifferentParallelPartitioning());
785
786 // if we have ghost values, do not allow
787 // writing to this vector at all.
788 Assert(!has_ghost_elements(), ExcGhostsPresent());
789
790 vector->elementWiseMultiply(1., *scaling_factors.vector, *vector, 0.);
791 }
792
793
794
795 template <typename Number, typename MemorySpace>
796 void
797 Vector<Number, MemorySpace>::equ(const Number a,
798 const Vector<Number, MemorySpace> &V)
799 {
800 AssertIsFinite(a);
801
802 // if we have ghost values, do not allow
803 // writing to this vector at all.
804 Assert(!has_ghost_elements(), ExcGhostsPresent());
805
806 // If we don't have the same map, copy.
807 if (vector->getMap()->isSameAs(*V.trilinos_vector().getMap()) == false)
808 this->sadd(0., a, V);
809 else
810 {
811 // Otherwise, just update
812 vector->update(a, V.trilinos_vector(), 0.);
813 }
814 }
815
816
817
818 template <typename Number, typename MemorySpace>
819 bool
820 Vector<Number, MemorySpace>::all_zero() const
821 {
822 // get a representation of the vector and
823 // loop over all the elements
824 Teuchos::ArrayRCP<const Number> data = vector->getData();
825 const size_type n_elements = vector->getLocalLength();
826 unsigned int flag = 0;
827 for (size_type i = 0; i < n_elements; ++i)
828 {
829 if (data[i] != Number(0))
830 {
831 flag = 1;
832 break;
833 }
834 }
835
836 // Check that the vector is zero on _all_ processors.
837 unsigned int num_nonzero =
838 Utilities::MPI::sum(flag,
839 Utilities::Trilinos::teuchos_comm_to_mpi_comm(
840 vector->getMap()->getComm()));
841
842 return num_nonzero == 0;
843 }
844
845
846
847 template <typename Number, typename MemorySpace>
848 bool
849 Vector<Number, MemorySpace>::is_non_negative() const
850 {
851 if constexpr (!std::is_same_v<Number, std::complex<double>> &&
852 !std::is_same_v<Number, std::complex<float>>)
853 {
854 // get a representation of the vector and
855 // loop over all the elements
856 Teuchos::ArrayRCP<const Number> data = vector->getData();
857 const size_type n_elements = vector->getLocalLength();
858 unsigned int flag = 0;
859 for (size_type i = 0; i < n_elements; ++i)
860 {
861 if (data[i] < Number(0))
862 {
863 flag = 1;
864 break;
865 }
866 }
867
868 // Check that the vector is non-negative on _all_ processors.
869 unsigned int num_negative =
870 Utilities::MPI::sum(flag,
871 Utilities::Trilinos::teuchos_comm_to_mpi_comm(
872 vector->getMap()->getComm()));
873 return num_negative == 0;
874 }
875 Assert(false,
876 ExcMessage("You can't ask a complex value "
877 "whether it is non-negative."));
878 return true;
879 }
880
881
882
883 template <typename Number, typename MemorySpace>
884 Number
885 Vector<Number, MemorySpace>::mean_value() const
886 {
887 Assert(!has_ghost_elements(), ExcGhostsPresent());
888
889 return vector->meanValue();
890 }
891
892
893
894 template <typename Number, typename MemorySpace>
895 typename Vector<Number, MemorySpace>::real_type
896 Vector<Number, MemorySpace>::l1_norm() const
897 {
898 Assert(!has_ghost_elements(), ExcGhostsPresent());
899
900 return vector->norm1();
901 }
902
903
904
905 template <typename Number, typename MemorySpace>
906 typename Vector<Number, MemorySpace>::real_type
907 Vector<Number, MemorySpace>::l2_norm() const
908 {
909 Assert(!has_ghost_elements(), ExcGhostsPresent());
910
911 return vector->norm2();
912 }
913
914
915
916 template <typename Number, typename MemorySpace>
917 typename Vector<Number, MemorySpace>::real_type
918 Vector<Number, MemorySpace>::linfty_norm() const
919 {
920 Assert(!has_ghost_elements(), ExcGhostsPresent());
921
922 return vector->normInf();
923 }
924
925
926
927 template <typename Number, typename MemorySpace>
928 typename Vector<Number, MemorySpace>::real_type
929 Vector<Number, MemorySpace>::norm_sqr() const
930 {
931 Vector<Number, MemorySpace>::real_type d = l2_norm();
932 return d * d;
933 }
934
935
936 template <typename Number, typename MemorySpace>
937 Number
938 Vector<Number, MemorySpace>::add_and_dot(
939 const Number a,
940 const Vector<Number, MemorySpace> &V,
941 const Vector<Number, MemorySpace> &W)
942 {
943 AssertIsFinite(a);
944
945 this->add(a, V);
946
947 return *this * W;
948 }
949
950
951
952 template <typename Number, typename MemorySpace>
953 bool
954 Vector<Number, MemorySpace>::operator==(
955 const Vector<Number, MemorySpace> &v) const
956 {
957 Assert(size() == v.size(), ExcDimensionMismatch(size(), v.size()));
958
959 const size_t this_local_length = vector->getLocalLength();
960 const size_t other_local_length = v.vector->getLocalLength();
961 if (this_local_length != other_local_length)
962 return false;
963
964 auto this_vector_2d = vector->template getLocalView<Kokkos::HostSpace>(
965 Tpetra::Access::ReadOnly);
966 auto other_vector_2d = v.vector->template getLocalView<Kokkos::HostSpace>(
967 Tpetra::Access::ReadOnly);
968
969 auto this_vector_1d = Kokkos::subview(this_vector_2d, Kokkos::ALL(), 0);
970 auto other_vector_1d = Kokkos::subview(other_vector_2d, Kokkos::ALL(), 0);
971
972 for (size_type i = 0; i < this_local_length; ++i)
973 if (this_vector_1d(i) != other_vector_1d(i))
974 return false;
975
976 return true;
977 }
978
979
980
981 template <typename Number, typename MemorySpace>
982 bool
983 Vector<Number, MemorySpace>::operator!=(
984 const Vector<Number, MemorySpace> &v) const
985 {
986 return (!(*this == v));
987 }
988
989
990
991 template <typename Number, typename MemorySpace>
992 typename Vector<Number, MemorySpace>::size_type
993 Vector<Number, MemorySpace>::size() const
994 {
995 return vector->getGlobalLength();
996 }
997
998
999
1000 template <typename Number, typename MemorySpace>
1001 typename Vector<Number, MemorySpace>::size_type
1002 Vector<Number, MemorySpace>::locally_owned_size() const
1003 {
1004 return vector->getLocalLength();
1005 }
1006
1007
1008
1009 template <typename Number, typename MemorySpace>
1010 std::pair<typename Vector<Number, MemorySpace>::size_type,
1011 typename Vector<Number, MemorySpace>::size_type>
1012 Vector<Number, MemorySpace>::local_range() const
1013 {
1014 const size_type begin = vector->getMap()->getMinGlobalIndex();
1015 const size_type end = vector->getMap()->getMaxGlobalIndex() + 1;
1016
1017 if constexpr (running_in_debug_mode())
1018 {
1019 const size_type n_local_elements =
1020 # if DEAL_II_TRILINOS_VERSION_GTE(14, 0, 0)
1021 vector->getMap()->getLocalNumElements();
1022 # else
1023 vector->getMap()->getNodeNumElements();
1024 # endif
1025 Assert(
1026 end - begin == n_local_elements,
1027 ExcMessage(
1028 "This function only makes sense if the elements that this "
1029 "vector stores on the current processor form a contiguous range. "
1030 "This does not appear to be the case for the current vector."));
1031 }
1032
1033 return std::make_pair(begin, end);
1034 }
1035
1036
1037
1038 template <typename Number, typename MemorySpace>
1039 bool
1040 Vector<Number, MemorySpace>::in_local_range(const size_type index) const
1041 {
1042 std::pair<size_type, size_type> range = local_range();
1043
1044 return ((index >= range.first) && (index < range.second));
1045 }
1046
1047
1048
1049 template <typename Number, typename MemorySpace>
1050 MPI_Comm
1051 Vector<Number, MemorySpace>::get_mpi_communicator() const
1052 {
1053 return Utilities::Trilinos::teuchos_comm_to_mpi_comm(
1054 vector->getMap()->getComm());
1055 }
1056
1057
1058
1059 template <typename Number, typename MemorySpace>
1060 IndexSet
1061 Vector<Number, MemorySpace>::locally_owned_elements() const
1062 {
1063 return IndexSet(vector->getMap());
1064 }
1065
1066
1067
1068 template <typename Number, typename MemorySpace>
1069 void
1070 Vector<Number, MemorySpace>::compress(
1071 const VectorOperation::values operation)
1072 {
1073 Assert(has_ghost == false,
1074 ExcMessage(
1075 "Calling compress() is only useful if a vector "
1076 "has been written into, but this is a vector with ghost "
1077 "elements and consequently is read-only. It does "
1078 "not make sense to call compress() for such "
1079 "vectors."));
1080
1081 if (!compressed)
1082 {
1083 Tpetra::CombineMode tpetra_operation = Tpetra::ZERO;
1084 if (operation == VectorOperation::insert)
1085 tpetra_operation = Tpetra::INSERT;
1086 else if (operation == VectorOperation::add)
1087 tpetra_operation = Tpetra::ADD;
1088 else
1089 DEAL_II_NOT_IMPLEMENTED();
1090
1091 Teuchos::RCP<const TpetraTypes::ExportType<MemorySpace>> exporter =
1092 Tpetra::createExport(nonlocal_vector->getMap(), vector->getMap());
1093 vector->doExport(*nonlocal_vector, *exporter, tpetra_operation);
1094
1095 compressed = true;
1096 }
1097 }
1098
1099
1100
1101 template <typename Number, typename MemorySpace>
1102 const TpetraTypes::VectorType<Number, MemorySpace> &
1103 Vector<Number, MemorySpace>::trilinos_vector() const
1104 {
1105 return *vector;
1106 }
1107
1108
1109
1110 template <typename Number, typename MemorySpace>
1111 TpetraTypes::VectorType<Number, MemorySpace> &
1112 Vector<Number, MemorySpace>::trilinos_vector()
1113 {
1114 return *vector;
1115 }
1116
1117
1118
1119 template <typename Number, typename MemorySpace>
1120 Teuchos::RCP<TpetraTypes::VectorType<Number, MemorySpace>>
1121 Vector<Number, MemorySpace>::trilinos_rcp()
1122 {
1123 return vector;
1124 }
1125
1126
1127
1128 template <typename Number, typename MemorySpace>
1129 Teuchos::RCP<const TpetraTypes::VectorType<Number, MemorySpace>>
1130 Vector<Number, MemorySpace>::trilinos_rcp() const
1131 {
1132 return vector.getConst();
1133 }
1134
1135
1136
1137 template <typename Number, typename MemorySpace>
1138 void
1139 Vector<Number, MemorySpace>::print(std::ostream &out,
1140 const unsigned int precision,
1141 const bool scientific,
1142 const bool across) const
1143 {
1144 AssertThrow(out.fail() == false, ExcIO());
1145 boost::io::ios_flags_saver restore_flags(out);
1146
1147 out.precision(precision);
1148 if (scientific)
1149 out.setf(std::ios::scientific, std::ios::floatfield);
1150 else
1151 out.setf(std::ios::fixed, std::ios::floatfield);
1152
1153 auto vector_2d = vector->template getLocalView<Kokkos::HostSpace>(
1154 Tpetra::Access::ReadOnly);
1155
1156 auto vector_1d = Kokkos::subview(vector_2d, Kokkos::ALL(), 0);
1157 const size_t local_length = vector->getLocalLength();
1158
1159 if (size() != local_length)
1160 {
1161 out << "size:" << size() << " locally_owned_size:" << local_length
1162 << " :" << std::endl;
1163 for (size_type i = 0; i < local_length; ++i)
1164 {
1165 const TrilinosWrappers::types::int_type global_row =
1166 vector->getMap()->getGlobalElement(i);
1167 out << "[" << global_row << "]: " << vector_1d(i) << std::endl;
1168 }
1169 }
1170 else
1171 {
1172 if (across)
1173 for (unsigned int i = 0; i < local_length; ++i)
1174 out << vector_1d(i) << ' ';
1175 else
1176 for (unsigned int i = 0; i < local_length; ++i)
1177 out << vector_1d(i) << std::endl;
1178 out << std::endl;
1179 }
1180
1181 // restore the representation
1182 // of the vector
1183 AssertThrow(out.fail() == false, ExcIO());
1184 }
1185
1186
1187
1188 template <typename Number, typename MemorySpace>
1189 MPI_Comm
1190 Vector<Number, MemorySpace>::mpi_comm() const
1191 {
1192 return Utilities::Trilinos::teuchos_comm_to_mpi_comm(
1193 vector->getMap()->getComm());
1194 }
1195
1196
1197 template <typename Number, typename MemorySpace>
1198 std::size_t
1199 Vector<Number, MemorySpace>::memory_consumption() const
1200 {
1201 return sizeof(*this) +
1202 vector->getLocalLength() *
1203 (sizeof(Number) + sizeof(TrilinosWrappers::types::int_type));
1204 }
1205
1206
1207
1208 template <typename Number, typename MemorySpace>
1209 void
1210 Vector<Number, MemorySpace>::create_tpetra_comm_pattern(
1211 const IndexSet &source_index_set,
1212 const MPI_Comm mpi_comm)
1213 {
1214 source_stored_elements = source_index_set;
1215
1216 tpetra_comm_pattern =
1217 Teuchos::rcp(new TpetraWrappers::CommunicationPattern<MemorySpace>(
1218 locally_owned_elements(), source_index_set, mpi_comm));
1219 }
1220 } // namespace TpetraWrappers
1221 } // namespace LinearAlgebra
1222
1223 DEAL_II_NAMESPACE_CLOSE
1224
1225 #else
1226
1227 // Make sure the scripts that create the C++20 module input files have
1228 // something to latch on if the preprocessor #ifdef above would
1229 // otherwise lead to an empty content of the file.
1230 DEAL_II_NAMESPACE_OPEN
1231 DEAL_II_NAMESPACE_CLOSE
1232
1233 #endif
1234
1235 #endif