Debian Codegraph @

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

raw
1 // ------------------------------------------------------------------------
2 //
3 // SPDX-License-Identifier: LGPL-2.1-or-later
4 // Copyright (C) 1999 - 2024 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_vector_templates_h
16 #define dealii_vector_templates_h
17
18
19 #include <deal.II/base/config.h>
20
21 #include <deal.II/base/numbers.h>
22 #include <deal.II/base/template_constraints.h>
23
24 #include <deal.II/lac/block_vector.h>
25 #include <deal.II/lac/exceptions.h>
26 #include <deal.II/lac/vector.h>
27 #include <deal.II/lac/vector_operations_internal.h>
28
29 #ifdef DEAL_II_WITH_PETSC
30 # include <deal.II/lac/petsc_vector_base.h>
31 #endif
32
33 #ifdef DEAL_II_WITH_TRILINOS
34 # include <deal.II/lac/trilinos_vector.h>
35 #endif
36
37 #ifdef DEAL_II_TRILINOS_WITH_TPETRA
38 # include <deal.II/lac/trilinos_tpetra_vector.h>
39 #endif
40
41
42 #include <algorithm>
43 #include <cmath>
44 #include <cstdio>
45 #include <cstring>
46 #include <iomanip>
47 #include <iostream>
48 #include <limits>
49 #include <memory>
50
51 DEAL_II_NAMESPACE_OPEN
52
53 template <typename Number>
54 Vector<Number>::Vector(const Vector<Number> &v)
55 {
56 *this = v;
57 }
58
59
60
61 template <typename Number>
62 void
63 Vector<Number>::apply_givens_rotation(const std::array<Number, 3> &csr,
64 const size_type i,
65 const size_type k)
66 {
67 auto &V = *this;
68 const Number t = V(i);
69 V(i) = csr[0] * V(i) + csr[1] * V(k);
70 V(k) = -csr[1] * t + csr[0] * V(k);
71 }
72
73
74
75 template <typename Number>
76 template <typename OtherNumber>
77 Vector<Number>::Vector(const Vector<OtherNumber> &v)
78 {
79 *this = v;
80 }
81
82
83
84 #ifdef DEAL_II_WITH_PETSC
85 namespace internal
86 {
87 template <typename Number>
88 void
89 copy_petsc_vector(const PETScWrappers::VectorBase &v,
90 ::dealii::Vector<Number> &out)
91 {
92 if (v.size() == 0)
93 {
94 out.reinit(0);
95 return;
96 }
97 // Create a sequential PETSc vector and then copy over the entries into
98 // the deal.II vector.
99 Vec sequential_vector;
100 VecScatter scatter_context;
101
102 PetscErrorCode ierr =
103 VecScatterCreateToAll(v, &scatter_context, &sequential_vector);
104 AssertThrow(ierr == 0, ExcPETScError(ierr));
105
106 ierr = VecScatterBegin(
107 scatter_context, v, sequential_vector, INSERT_VALUES, SCATTER_FORWARD);
108 AssertThrow(ierr == 0, ExcPETScError(ierr));
109 ierr = VecScatterEnd(
110 scatter_context, v, sequential_vector, INSERT_VALUES, SCATTER_FORWARD);
111 AssertThrow(ierr == 0, ExcPETScError(ierr));
112
113 const PetscScalar *start_ptr;
114 ierr = VecGetArrayRead(sequential_vector, &start_ptr);
115 AssertThrow(ierr == 0, ExcPETScError(ierr));
116
117 const PETScWrappers::VectorBase::size_type v_size = v.size();
118 if (out.size() != v_size)
119 out.reinit(v_size, true);
120
121 internal::VectorOperations::copy(start_ptr,
122 start_ptr + out.size(),
123 out.begin());
124 ierr = VecRestoreArrayRead(sequential_vector, &start_ptr);
125 AssertThrow(ierr == 0, ExcPETScError(ierr));
126
127 ierr = VecScatterDestroy(&scatter_context);
128 AssertNothrow(ierr == 0, ExcPETScError(ierr));
129 ierr = VecDestroy(&sequential_vector);
130 AssertNothrow(ierr == 0, ExcPETScError(ierr));
131 }
132 } // namespace internal
133
134
135
136 template <typename Number>
137 Vector<Number>::Vector(const PETScWrappers::VectorBase &v)
138 {
139 internal::copy_petsc_vector(v, *this);
140 }
141 #endif
142
143
144 #ifdef DEAL_II_WITH_TRILINOS
145
146 template <typename Number>
147 Vector<Number>::Vector(const TrilinosWrappers::MPI::Vector &v)
148 : values(v.size())
149 {
150 if (size() != 0)
151 {
152 // Copy the distributed vector to
153 // a local one at all processors
154 // that know about the original vector.
155 // TODO: There could
156 // be a better solution than
157 // this, but it has not yet been
158 // found.
159 TrilinosWrappers::MPI::Vector localized_vector;
160 localized_vector.reinit(complete_index_set(size()),
161 v.get_mpi_communicator());
162 localized_vector.reinit(v, false, true);
163
164 Assert(localized_vector.size() == size(),
165 ExcDimensionMismatch(localized_vector.size(), size()));
166
167 // get a representation of the vector
168 // and copy it
169 TrilinosScalar **start_ptr;
170
171 int ierr = localized_vector.trilinos_vector().ExtractView(&start_ptr);
172 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
173
174 std::copy(start_ptr[0], start_ptr[0] + size(), begin());
175
176 maybe_reset_thread_partitioner();
177 }
178 }
179
180 #endif
181
182
183 #ifdef DEAL_II_TRILINOS_WITH_TPETRA
184
185 template <typename Number>
186 template <typename OtherNumber, typename MemorySpace>
187 Vector<Number>::Vector(
188 const LinearAlgebra::TpetraWrappers::Vector<OtherNumber, MemorySpace> &v)
189 : values(v.size())
190 {
191 static_assert(
192 std::is_same<Number, OtherNumber>::value,
193 "TpetraWrappers::Vector and dealii::Vector must use the same number type here.");
194
195 if (size() != 0)
196 {
197 // Copy the distributed vector to
198 // a local one at all processors
199 // that know about the original vector.
200 LinearAlgebra::TpetraWrappers::TpetraTypes::VectorType<OtherNumber,
201 MemorySpace>
202 localized_vector(
203 complete_index_set(size())
204 .template make_tpetra_map_rcp<
205 LinearAlgebra::TpetraWrappers::TpetraTypes::NodeType<
206 MemorySpace>>(),
207 v.get_mpi_communicator());
208
209 Teuchos::RCP<const LinearAlgebra::TpetraWrappers::TpetraTypes::ImportType<
210 MemorySpace>>
211 importer = Tpetra::createImport(v.trilinos_vector().getMap(),
212 localized_vector.getMap());
213
214 localized_vector.doImport(v.trilinos_vector(), *importer, Tpetra::INSERT);
215
216 // get a kokkos view from the localized_vector
217 # if DEAL_II_TRILINOS_VERSION_GTE(13, 2, 0)
218 auto localized_vector_2d =
219 localized_vector.template getLocalView<Kokkos::HostSpace>(
220 Tpetra::Access::ReadOnly);
221 # else
222 localized_vector.template sync<Kokkos::HostSpace>();
223 auto localized_vector_2d =
224 localized_vector.template getLocalView<Kokkos::HostSpace>();
225 # endif
226 auto localized_vector_1d =
227 Kokkos::subview(localized_vector_2d, Kokkos::ALL(), 0);
228 const size_t local_length = localized_vector.getLocalLength();
229
230 Kokkos::DefaultHostExecutionSpace exec;
231 Kokkos::View<Number *, Kokkos::HostSpace> values_view(values.data(),
232 local_length);
233 Kokkos::deep_copy(exec, values_view, localized_vector_1d);
234 exec.fence();
235 }
236 }
237
238 #endif
239
240
241 template <typename Number>
242 inline Vector<Number> &
243 Vector<Number>::operator=(const Vector<Number> &v)
244 {
245 if (PointerComparison::equal(this, &v))
246 return *this;
247
248 if (size() != v.size())
249 reinit(v, true);
250
251 if (0 < size())
252 {
253 dealii::internal::VectorOperations::Vector_copy<Number, Number> copier(
254 v.begin(), begin());
255 internal::VectorOperations::parallel_for(copier,
256 0,
257 size(),
258 thread_loop_partitioner);
259 }
260
261 return *this;
262 }
263
264
265
266 template <typename Number>
267 template <typename Number2>
268 inline Vector<Number> &
269 Vector<Number>::operator=(const Vector<Number2> &v)
270 {
271 if (size() != v.size())
272 reinit(v, true);
273
274 dealii::internal::VectorOperations::Vector_copy<Number, Number2> copier(
275 v.begin(), begin());
276 internal::VectorOperations::parallel_for(copier,
277 0,
278 size(),
279 thread_loop_partitioner);
280
281 return *this;
282 }
283
284
285
286 template <typename Number>
287 inline void
288 Vector<Number>::reinit(const size_type n, const bool omit_zeroing_entries)
289 {
290 do_reinit(n, omit_zeroing_entries, true);
291 }
292
293
294
295 template <typename Number>
296 inline void
297 Vector<Number>::grow_or_shrink(const size_type n)
298 {
299 values.resize(n);
300
301 maybe_reset_thread_partitioner();
302 }
303
304
305
306 template <typename Number>
307 bool
308 Vector<Number>::all_zero() const
309 {
310 Assert(size() != 0, ExcEmptyObject());
311
312 for (size_type i = 0; i < size(); ++i)
313 if (values[i] != Number())
314 return false;
315 return true;
316 }
317
318
319
320 template <typename Number>
321 bool
322 Vector<Number>::is_non_negative() const
323 {
324 Assert(size() != 0, ExcEmptyObject());
325
326 for (size_type i = 0; i < size(); ++i)
327 if (!internal::VectorOperations::is_non_negative(values[i]))
328 return false;
329
330 return true;
331 }
332
333
334
335 template <typename Number>
336 Vector<Number> &
337 Vector<Number>::operator=(const Number s)
338 {
339 AssertIsFinite(s);
340 if (s != Number())
341 Assert(size() != 0, ExcEmptyObject());
342
343 if (size() > 0)
344 {
345 internal::VectorOperations::Vector_set<Number> setter(s, values.begin());
346 internal::VectorOperations::parallel_for(setter,
347 0,
348 size(),
349 thread_loop_partitioner);
350 }
351
352 return *this;
353 }
354
355
356
357 template <typename Number>
358 Vector<Number> &
359 Vector<Number>::operator*=(const Number factor)
360 {
361 AssertIsFinite(factor);
362
363 Assert(size() != 0, ExcEmptyObject());
364
365 internal::VectorOperations::Vectorization_multiply_factor<Number>
366 vector_multiply(values.begin(), factor);
367
368 internal::VectorOperations::parallel_for(vector_multiply,
369 0,
370 size(),
371 thread_loop_partitioner);
372
373 return *this;
374 }
375
376
377
378 template <typename Number>
379 void
380 Vector<Number>::add(const Number a, const Vector<Number> &v)
381 {
382 AssertIsFinite(a);
383
384 Assert(size() != 0, ExcEmptyObject());
385 Assert(size() == v.size(), ExcDimensionMismatch(size(), v.size()));
386
387 internal::VectorOperations::Vectorization_add_av<Number> vector_add_av(
388 values.begin(), v.values.begin(), a);
389 internal::VectorOperations::parallel_for(vector_add_av,
390 0,
391 size(),
392 thread_loop_partitioner);
393 }
394
395
396
397 template <typename Number>
398 void
399 Vector<Number>::sadd(const Number x, const Number a, const Vector<Number> &v)
400 {
401 AssertIsFinite(x);
402 AssertIsFinite(a);
403
404 Assert(size() != 0, ExcEmptyObject());
405 Assert(size() == v.size(), ExcDimensionMismatch(size(), v.size()));
406
407 internal::VectorOperations::Vectorization_sadd_xav<Number> vector_sadd_xav(
408 values.begin(), v.values.begin(), a, x);
409 internal::VectorOperations::parallel_for(vector_sadd_xav,
410 0,
411 size(),
412 thread_loop_partitioner);
413 }
414
415
416
417 template <typename Number>
418 template <typename Number2>
419 Number
420 Vector<Number>::operator*(const Vector<Number2> &v) const
421 {
422 Assert(size() != 0, ExcEmptyObject());
423
424 if (PointerComparison::equal(this, &v))
425 return norm_sqr();
426
427 Assert(size() == v.size(), ExcDimensionMismatch(size(), v.size()));
428
429 Number sum;
430 internal::VectorOperations::Dot<Number, Number2> dot(values.begin(),
431 v.values.begin());
432 internal::VectorOperations::parallel_reduce(
433 dot, 0, size(), sum, thread_loop_partitioner);
434 AssertIsFinite(sum);
435
436 return sum;
437 }
438
439
440
441 template <typename Number>
442 typename Vector<Number>::real_type
443 Vector<Number>::norm_sqr() const
444 {
445 Assert(size() != 0, ExcEmptyObject());
446
447 real_type sum;
448 internal::VectorOperations::Norm2<Number, real_type> norm2(values.begin());
449 internal::VectorOperations::parallel_reduce(
450 norm2, 0, size(), sum, thread_loop_partitioner);
451
452 AssertIsFinite(sum);
453
454 return sum;
455 }
456
457
458
459 template <typename Number>
460 Number
461 Vector<Number>::mean_value() const
462 {
463 Assert(size() != 0, ExcEmptyObject());
464
465 Number sum;
466 internal::VectorOperations::MeanValue<Number> mean(values.begin());
467 internal::VectorOperations::parallel_reduce(
468 mean, 0, size(), sum, thread_loop_partitioner);
469
470 return sum / real_type(size());
471 }
472
473
474
475 template <typename Number>
476 typename Vector<Number>::real_type
477 Vector<Number>::l1_norm() const
478 {
479 Assert(size() != 0, ExcEmptyObject());
480
481 real_type sum;
482 internal::VectorOperations::Norm1<Number, real_type> norm1(values.begin());
483 internal::VectorOperations::parallel_reduce(
484 norm1, 0, size(), sum, thread_loop_partitioner);
485
486 return sum;
487 }
488
489
490
491 template <typename Number>
492 typename Vector<Number>::real_type
493 Vector<Number>::l2_norm() const
494 {
495 // if l2_norm()^2 is finite and non-zero, the answer is computed as
496 // std::sqrt(norm_sqr()). If norm_sqr() is infinite or zero, the l2 norm
497 // might still be finite. In that case, recompute it (this is a rare case,
498 // so working on the vector twice is uncritical and paid off by the extended
499 // precision) using the BLAS approach with a weight, see e.g. dnrm2.f.
500 Assert(size() != 0, ExcEmptyObject());
501
502 real_type norm_square;
503 internal::VectorOperations::Norm2<Number, real_type> norm2(values.begin());
504 internal::VectorOperations::parallel_reduce(
505 norm2, 0, size(), norm_square, thread_loop_partitioner);
506 if (numbers::is_finite(norm_square) &&
507 norm_square >= std::numeric_limits<real_type>::min())
508 return static_cast<typename Vector<Number>::real_type>(
509 std::sqrt(norm_square));
510 else
511 {
512 real_type scale = 0.;
513 real_type sum = 1.;
514 for (size_type i = 0; i < size(); ++i)
515 {
516 if (values[i] != Number())
517 {
518 const real_type abs_x =
519 numbers::NumberTraits<Number>::abs(values[i]);
520 if (scale < abs_x)
521 {
522 sum = 1 + sum * (scale / abs_x) * (scale / abs_x);
523 scale = abs_x;
524 }
525 else
526 sum += (abs_x / scale) * (abs_x / scale);
527 }
528 }
529 AssertIsFinite(scale * std::sqrt(sum));
530 return static_cast<typename Vector<Number>::real_type>(scale *
531 std::sqrt(sum));
532 }
533 }
534
535
536
537 template <typename Number>
538 typename Vector<Number>::real_type
539 Vector<Number>::lp_norm(const real_type p) const
540 {
541 Assert(size() != 0, ExcEmptyObject());
542
543 if (p == 1.)
544 return l1_norm();
545 else if (p == 2.)
546 return l2_norm();
547
548 real_type sum;
549 internal::VectorOperations::NormP<Number, real_type> normp(values.begin(), p);
550 internal::VectorOperations::parallel_reduce(
551 normp, 0, size(), sum, thread_loop_partitioner);
552
553 if (numbers::is_finite(sum) && sum >= std::numeric_limits<real_type>::min())
554 return std::pow(sum, static_cast<real_type>(1. / p));
555 else
556 {
557 real_type scale = 0.;
558 real_type sum = 1.;
559 for (size_type i = 0; i < size(); ++i)
560 {
561 if (values[i] != Number())
562 {
563 const real_type abs_x =
564 numbers::NumberTraits<Number>::abs(values[i]);
565 if (scale < abs_x)
566 {
567 sum = 1. + sum * std::pow(scale / abs_x, p);
568 scale = abs_x;
569 }
570 else
571 sum += std::pow(abs_x / scale, p);
572 }
573 }
574 return scale * std::pow(sum, static_cast<real_type>(1. / p));
575 }
576 }
577
578
579
580 template <typename Number>
581 typename Vector<Number>::real_type
582 Vector<Number>::linfty_norm() const
583 {
584 Assert(size() != 0, ExcEmptyObject());
585
586 real_type max = 0.;
587
588 for (size_type i = 0; i < size(); ++i)
589 max = std::max(numbers::NumberTraits<Number>::abs(values[i]), max);
590
591 return max;
592 }
593
594
595
596 template <typename Number>
597 Number
598 Vector<Number>::add_and_dot(const Number a,
599 const Vector<Number> &V,
600 const Vector<Number> &W)
601 {
602 Assert(size() != 0, ExcEmptyObject());
603 AssertDimension(size(), V.size());
604 AssertDimension(size(), W.size());
605
606 Number sum;
607 internal::VectorOperations::AddAndDot<Number> adder(values.begin(),
608 V.values.begin(),
609 W.values.begin(),
610 a);
611 internal::VectorOperations::parallel_reduce(
612 adder, 0, size(), sum, thread_loop_partitioner);
613 AssertIsFinite(sum);
614
615 return sum;
616 }
617
618
619
620 template <typename Number>
621 void
622 Vector<Number>::extract_subvector_to(
623 const ArrayView<const types::global_dof_index> &indices,
624 const ArrayView<Number> &elements) const
625 {
626 AssertDimension(indices.size(), elements.size());
627 for (unsigned int i = 0; i < indices.size(); ++i)
628 {
629 AssertIndexRange(indices[i], size());
630 elements[i] = (*this)[indices[i]];
631 }
632 }
633
634
635
636 template <typename Number>
637 Vector<Number> &
638 Vector<Number>::operator+=(const Vector<Number> &v)
639 {
640 Assert(size() != 0, ExcEmptyObject());
641 Assert(size() == v.size(), ExcDimensionMismatch(size(), v.size()));
642
643 internal::VectorOperations::Vectorization_add_v<Number> vector_add(
644 values.begin(), v.values.begin());
645 internal::VectorOperations::parallel_for(vector_add,
646 0,
647 size(),
648 thread_loop_partitioner);
649 return *this;
650 }
651
652
653
654 template <typename Number>
655 Vector<Number> &
656 Vector<Number>::operator-=(const Vector<Number> &v)
657 {
658 Assert(size() != 0, ExcEmptyObject());
659 Assert(size() == v.size(), ExcDimensionMismatch(size(), v.size()));
660
661 internal::VectorOperations::Vectorization_subtract_v<Number> vector_subtract(
662 values.begin(), v.values.begin());
663 internal::VectorOperations::parallel_for(vector_subtract,
664 0,
665 size(),
666 thread_loop_partitioner);
667
668 return *this;
669 }
670
671
672
673 template <typename Number>
674 void
675 Vector<Number>::add(const Number v)
676 {
677 Assert(size() != 0, ExcEmptyObject());
678
679 internal::VectorOperations::Vectorization_add_factor<Number> vector_add(
680 values.begin(), v);
681 internal::VectorOperations::parallel_for(vector_add,
682 0,
683 size(),
684 thread_loop_partitioner);
685 }
686
687
688
689 template <typename Number>
690 void
691 Vector<Number>::add(const Number a,
692 const Vector<Number> &v,
693 const Number b,
694 const Vector<Number> &w)
695 {
696 AssertIsFinite(a);
697 AssertIsFinite(b);
698
699 Assert(size() != 0, ExcEmptyObject());
700 Assert(size() == v.size(), ExcDimensionMismatch(size(), v.size()));
701 Assert(size() == w.size(), ExcDimensionMismatch(size(), w.size()));
702
703 internal::VectorOperations::Vectorization_add_avpbw<Number> vector_add(
704 values.begin(), v.values.begin(), w.values.begin(), a, b);
705 internal::VectorOperations::parallel_for(vector_add,
706 0,
707 size(),
708 thread_loop_partitioner);
709 }
710
711
712
713 template <typename Number>
714 void
715 Vector<Number>::sadd(const Number x, const Vector<Number> &v)
716 {
717 AssertIsFinite(x);
718
719 Assert(size() != 0, ExcEmptyObject());
720 Assert(size() == v.size(), ExcDimensionMismatch(size(), v.size()));
721
722 internal::VectorOperations::Vectorization_sadd_xv<Number> vector_sadd(
723 values.begin(), v.values.begin(), x);
724 internal::VectorOperations::parallel_for(vector_sadd,
725 0,
726 size(),
727 thread_loop_partitioner);
728 }
729
730
731
732 template <typename Number>
733 void
734 Vector<Number>::scale(const Vector<Number> &s)
735 {
736 Assert(size() != 0, ExcEmptyObject());
737 Assert(size() == s.size(), ExcDimensionMismatch(size(), s.size()));
738
739 internal::VectorOperations::Vectorization_scale<Number> vector_scale(
740 values.begin(), s.values.begin());
741 internal::VectorOperations::parallel_for(vector_scale,
742 0,
743 size(),
744 thread_loop_partitioner);
745 }
746
747
748
749 template <typename Number>
750 template <typename Number2>
751 void
752 Vector<Number>::scale(const Vector<Number2> &s)
753 {
754 Assert(size() != 0, ExcEmptyObject());
755 Assert(size() == s.size(), ExcDimensionMismatch(size(), s.size()));
756
757 for (size_type i = 0; i < size(); ++i)
758 values[i] *= Number(s.values[i]);
759 }
760
761
762
763 template <typename Number>
764 void
765 Vector<Number>::equ(const Number a, const Vector<Number> &u)
766 {
767 AssertIsFinite(a);
768
769 Assert(size() != 0, ExcEmptyObject());
770 Assert(size() == u.size(), ExcDimensionMismatch(size(), u.size()));
771
772 internal::VectorOperations::Vectorization_equ_au<Number> vector_equ(
773 values.begin(), u.values.begin(), a);
774 internal::VectorOperations::parallel_for(vector_equ,
775 0,
776 size(),
777 thread_loop_partitioner);
778 }
779
780
781
782 template <typename Number>
783 template <typename Number2>
784 void
785 Vector<Number>::equ(const Number a, const Vector<Number2> &u)
786 {
787 AssertIsFinite(a);
788
789 Assert(size() != 0, ExcEmptyObject());
790 Assert(size() == u.size(), ExcDimensionMismatch(size(), u.size()));
791
792 // set the result vector to a*u. we have to
793 // convert the elements of u to the type of
794 // the result vector. this is necessary
795 // because
796 // operator*(complex<float>,complex<double>)
797 // is not defined by default
798 for (size_type i = 0; i < size(); ++i)
799 values[i] = a * Number(u.values[i]);
800 }
801
802
803
804 template <typename Number>
805 Vector<Number> &
806 Vector<Number>::operator=(const BlockVector<Number> &v)
807 {
808 if (v.size() != size())
809 reinit(v.size(), true);
810
811 size_type this_index = 0;
812 for (size_type b = 0; b < v.n_blocks(); ++b)
813 for (size_type i = 0; i < v.block(b).size(); ++i, ++this_index)
814 values[this_index] = v.block(b)(i);
815
816 return *this;
817 }
818
819
820
821 #ifdef DEAL_II_WITH_PETSC
822 template <typename Number>
823 Vector<Number> &
824 Vector<Number>::operator=(const PETScWrappers::VectorBase &v)
825 {
826 internal::copy_petsc_vector(v, *this);
827 return *this;
828 }
829 #endif
830
831
832 #ifdef DEAL_II_WITH_TRILINOS
833
834 template <typename Number>
835 Vector<Number> &
836 Vector<Number>::operator=(const TrilinosWrappers::MPI::Vector &v)
837 {
838 if (v.size() != size())
839 reinit(v.size(), true);
840 if (size() != 0)
841 {
842 // Copy the distributed vector to
843 // a local one at all processors
844 // that know about the original vector.
845 // TODO: There could
846 // be a better solution than
847 // this, but it has not yet been
848 // found.
849 TrilinosWrappers::MPI::Vector localized_vector;
850 localized_vector.reinit(complete_index_set(size()),
851 v.get_mpi_communicator());
852 localized_vector.reinit(v, false, true);
853
854 Assert(localized_vector.size() == size(),
855 ExcDimensionMismatch(localized_vector.size(), size()));
856
857 // get a representation of the vector
858 // and copy it
859 TrilinosScalar **start_ptr;
860
861 int ierr = localized_vector.trilinos_vector().ExtractView(&start_ptr);
862 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
863
864 std::copy(start_ptr[0], start_ptr[0] + size(), begin());
865 }
866
867 return *this;
868 }
869
870 #endif
871
872
873
874 #ifdef DEAL_II_TRILINOS_WITH_TPETRA
875
876 template <typename Number>
877 template <typename OtherNumber, typename MemorySpace>
878 Vector<Number> &
879 Vector<Number>::operator=(
880 const LinearAlgebra::TpetraWrappers::Vector<OtherNumber, MemorySpace> &v)
881 {
882 static_assert(
883 std::is_same<Number, OtherNumber>::value,
884 "TpetraWrappers::Vector and dealii::Vector must use the same number type here.");
885
886 if (v.size() != size())
887 reinit(v.size(), true);
888
889 if (size() != 0)
890 {
891 // Copy the distributed vector to
892 // a local one at all processors
893 // that know about the original vector.
894 LinearAlgebra::TpetraWrappers::TpetraTypes::VectorType<OtherNumber,
895 MemorySpace>
896 localized_vector(
897 complete_index_set(size())
898 .template make_tpetra_map_rcp<
899 LinearAlgebra::TpetraWrappers::TpetraTypes::NodeType<
900 MemorySpace>>(),
901 v.get_mpi_communicator());
902
903 Teuchos::RCP<const LinearAlgebra::TpetraWrappers::TpetraTypes::ImportType<
904 MemorySpace>>
905 importer = Tpetra::createImport(v.trilinos_vector().getMap(),
906 localized_vector.getMap());
907
908 localized_vector.doImport(v.trilinos_vector(), *importer, Tpetra::INSERT);
909
910 // get a kokkos view from the localized_vector
911 # if DEAL_II_TRILINOS_VERSION_GTE(13, 2, 0)
912 auto localized_vector_2d =
913 localized_vector.template getLocalView<Kokkos::HostSpace>(
914 Tpetra::Access::ReadOnly);
915 # else
916 localized_vector.template sync<Kokkos::HostSpace>();
917 auto localized_vector_2d =
918 localized_vector.template getLocalView<Kokkos::HostSpace>();
919 # endif
920 auto localized_vector_1d =
921 Kokkos::subview(localized_vector_2d, Kokkos::ALL(), 0);
922 const size_t local_length = localized_vector.getLocalLength();
923
924 Kokkos::DefaultHostExecutionSpace exec;
925 Kokkos::View<Number *, Kokkos::HostSpace> values_view(values.data(),
926 local_length);
927 Kokkos::deep_copy(exec, values_view, localized_vector_1d);
928 exec.fence();
929 }
930
931 return *this;
932 }
933
934 #endif
935
936
937
938 template <typename Number>
939 template <typename Number2>
940 bool
941 Vector<Number>::operator==(const Vector<Number2> &v) const
942 {
943 Assert(size() == v.size(), ExcDimensionMismatch(size(), v.size()));
944
945 // compare the two vector. we have to
946 // convert the elements of v to the type of
947 // the result vector. this is necessary
948 // because
949 // operator==(complex<float>,complex<double>)
950 // is not defined by default
951 for (size_type i = 0; i < size(); ++i)
952 if (values[i] != Number(v.values[i]))
953 return false;
954
955 return true;
956 }
957
958
959
960 template <typename Number>
961 void
962 Vector<Number>::print(std::ostream &out,
963 const unsigned int precision,
964 const bool scientific,
965 const bool across) const
966 {
967 Assert(size() != 0, ExcEmptyObject());
968 AssertThrow(out.fail() == false, ExcIO());
969
970 std::ios::fmtflags old_flags = out.flags();
971 unsigned int old_precision = out.precision(precision);
972
973 out.precision(precision);
974 if (scientific)
975 out.setf(std::ios::scientific, std::ios::floatfield);
976 else
977 out.setf(std::ios::fixed, std::ios::floatfield);
978
979 if (across)
980 for (size_type i = 0; i < size(); ++i)
981 out << values[i] << ' ';
982 else
983 for (size_type i = 0; i < size(); ++i)
984 out << values[i] << std::endl;
985 out << std::endl;
986
987 AssertThrow(out.fail() == false, ExcIO());
988 // reset output format
989 out.flags(old_flags);
990 out.precision(old_precision);
991 }
992
993
994
995 template <typename Number>
996 void
997 Vector<Number>::block_write(std::ostream &out) const
998 {
999 AssertThrow(out.fail() == false, ExcIO());
1000
1001 out << std::to_string(size()) << "\n[";
1002 out.write(reinterpret_cast<const char *>(begin()),
1003 reinterpret_cast<const char *>(end()) -
1004 reinterpret_cast<const char *>(begin()));
1005 out << ']';
1006
1007 AssertThrow(out.fail() == false, ExcIO());
1008 }
1009
1010
1011
1012 template <typename Number>
1013 void
1014 Vector<Number>::block_read(std::istream &in)
1015 {
1016 AssertThrow(in.fail() == false, ExcIO());
1017
1018 size_type sz;
1019
1020 char buf[16];
1021
1022
1023 in.getline(buf, 16, '\n');
1024 sz = std::atoi(buf);
1025
1026 // fast initialization, since the
1027 // data elements are overwritten anyway
1028 reinit(sz, true);
1029
1030 char c;
1031 in.read(&c, 1);
1032 AssertThrow(c == '[', ExcIO());
1033
1034 in.read(reinterpret_cast<char *>(begin()),
1035 reinterpret_cast<const char *>(end()) -
1036 reinterpret_cast<const char *>(begin()));
1037
1038 in.read(&c, 1);
1039 AssertThrow(c == ']', ExcIO());
1040 }
1041
1042
1043
1044 template <typename Number>
1045 IndexSet
1046 Vector<Number>::locally_owned_elements() const
1047 {
1048 return complete_index_set(size());
1049 }
1050
1051
1052
1053 template <typename Number>
1054 std::size_t
1055 Vector<Number>::memory_consumption() const
1056 {
1057 return sizeof(*this) + values.memory_consumption() - sizeof(values);
1058 }
1059
1060
1061
1062 template <typename Number>
1063 void
1064 Vector<Number>::maybe_reset_thread_partitioner()
1065 {
1066 if (size() >= 4 * internal::VectorImplementation::minimum_parallel_grain_size)
1067 {
1068 if (thread_loop_partitioner == nullptr)
1069 thread_loop_partitioner =
1070 std::make_shared<parallel::internal::TBBPartitioner>();
1071 }
1072 else
1073 thread_loop_partitioner.reset();
1074 }
1075
1076
1077
1078 template <typename Number>
1079 void
1080 Vector<Number>::do_reinit(const size_type new_size,
1081 const bool omit_zeroing_entries,
1082 const bool reset_partitioner)
1083 {
1084 values.resize_fast(new_size);
1085 if (!omit_zeroing_entries)
1086 values.fill();
1087
1088 if (reset_partitioner)
1089 maybe_reset_thread_partitioner();
1090 }
1091
1092
1093 DEAL_II_NAMESPACE_CLOSE
1094
1095 #endif