Xpetra  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
Xpetra_BlockedVector_def.hpp
Go to the documentation of this file.
1 // @HEADER
2 // *****************************************************************************
3 // Xpetra: A linear algebra interface package
4 //
5 // Copyright 2012 NTESS and the Xpetra contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
10 #ifndef XPETRA_BLOCKEDVECTOR_DEF_HPP
11 #define XPETRA_BLOCKEDVECTOR_DEF_HPP
12 
13 #include "Xpetra_BlockedVector_decl.hpp"
14 
15 #include "Xpetra_BlockedMultiVector.hpp"
16 #include "Xpetra_Exceptions.hpp"
17 
18 namespace Xpetra {
19 
20 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
21 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
22  BlockedVector(const Teuchos::RCP<const Xpetra::BlockedMap<LocalOrdinal, GlobalOrdinal, Node>>& map, bool zeroOut)
23  : Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(map, 1, zeroOut) {}
24 
25 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
26 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
27  BlockedVector(Teuchos::RCP<const Xpetra::BlockedMap<LocalOrdinal, GlobalOrdinal, Node>> bmap,
28  Teuchos::RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> v)
29  : Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(bmap, v) {}
30 
31 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
32 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
33  BlockedVector(Teuchos::RCP<const Xpetra::MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>> mapExtractor,
34  Teuchos::RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> v)
35  : Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(mapExtractor, v) {}
36 
37 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
38 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
39  ~BlockedVector() {}
40 
41 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
42 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>&
43 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
44 operator=(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& rhs) {
45  assign(rhs); // dispatch to protected virtual method
46  return *this;
47 }
48 
49 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
50 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
51  replaceGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar& value) {
52  BlockedMultiVector::replaceGlobalValue(globalRow, vectorIndex, value);
53 }
54 
55 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
56 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
57  sumIntoGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar& value) {
58  BlockedMultiVector::sumIntoGlobalValue(globalRow, vectorIndex, value);
59 }
60 
61 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
62 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
63  replaceLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar& value) {
64  BlockedMultiVector::replaceLocalValue(myRow, vectorIndex, value);
65 }
66 
67 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
68 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
69  sumIntoLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar& value) {
70  BlockedMultiVector::sumIntoLocalValue(myRow, vectorIndex, value);
71 }
72 
73 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
74 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
75  replaceGlobalValue(GlobalOrdinal globalRow, const Scalar& value) {
76  BlockedMultiVector::replaceGlobalValue(globalRow, 0, value);
77 }
78 
79 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
80 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
81  sumIntoGlobalValue(GlobalOrdinal globalRow, const Scalar& value) {
82  BlockedMultiVector::sumIntoGlobalValue(globalRow, 0, value);
83 }
84 
85 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
86 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
87  replaceLocalValue(LocalOrdinal myRow, const Scalar& value) {
88  BlockedMultiVector::replaceLocalValue(myRow, 0, value);
89 }
90 
91 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
92 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
93  sumIntoLocalValue(LocalOrdinal myRow, const Scalar& value) {
94  BlockedMultiVector::sumIntoLocalValue(myRow, 0, value);
95 }
96 
97 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
98 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
99  putScalar(const Scalar& value) {
100  BlockedMultiVector::putScalar(value);
101 }
102 
103 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
104 Teuchos::RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
105 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
106  getVector(size_t j) const {
107  return BlockedMultiVector::getVector(j);
108 }
109 
110 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
111 Teuchos::RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
112 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
113  getVectorNonConst(size_t j) {
114  return BlockedMultiVector::getVectorNonConst(j);
115 }
116 
117 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
118 Teuchos::ArrayRCP<const Scalar>
119 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
120  getData(size_t j) const {
121  return BlockedMultiVector::getData(j);
122 }
123 
124 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
125 Teuchos::ArrayRCP<Scalar>
126 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
127  getDataNonConst(size_t j) {
128  return BlockedMultiVector::getDataNonConst(j);
129 }
130 
131 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
132 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
133  dot(const MultiVector& A, const Teuchos::ArrayView<Scalar>& dots) const {
134  BlockedMultiVector::dot(A, dots);
135  return;
136 }
137 
138 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
139 Scalar
140 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
141  dot(const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A) const {
142  Teuchos::Array<Scalar> dots = Teuchos::Array<Scalar>(1);
143  BlockedMultiVector::dot(A, dots);
144  return dots[0];
145 }
146 
147 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
148 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
149  abs(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A) {
150  BlockedMultiVector::abs(A);
151  return;
152 }
153 
154 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
155 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
156  reciprocal(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A) {
157  BlockedMultiVector::reciprocal(A);
158  return;
159 }
160 
161 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
162 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
163  scale(const Scalar& alpha) {
164  BlockedMultiVector::scale(alpha);
165  return;
166 }
167 
168 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
169 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
170  scale(Teuchos::ArrayView<const Scalar> alpha) {
171  BlockedMultiVector::scale(alpha);
172  return;
173 }
174 
175 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
176 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
177  update(const Scalar& alpha,
178  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A,
179  const Scalar& beta) {
180  BlockedMultiVector::update(alpha, A, beta);
181  return;
182 }
183 
184 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
185 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
186  update(const Scalar& alpha,
187  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A,
188  const Scalar& beta,
189  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& B,
190  const Scalar& gamma) {
191  BlockedMultiVector::update(alpha, A, beta, B, gamma);
192  return;
193 }
194 
195 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
196 typename Teuchos::ScalarTraits<Scalar>::magnitudeType
197 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
198  norm1() const {
199  using Array = Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>;
200  Array norm = Array(1);
201  this->norm1(norm);
202  return norm[0];
203 }
204 
205 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
206 typename Teuchos::ScalarTraits<Scalar>::magnitudeType
207 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
208  norm2() const {
209  Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> norm =
210  Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>(1);
211  this->norm2(norm);
212  return norm[0];
213 }
214 
215 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
216 typename Teuchos::ScalarTraits<Scalar>::magnitudeType
217 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
218  normInf() const {
219  Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>
220  norm = Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>(1);
221  this->normInf(norm);
222  return norm[0];
223 }
224 
225 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
226 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
227  norm1(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>& norms) const {
228  BlockedMultiVector::norm1(norms);
229 }
230 
231 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
232 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
233  norm2(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>& norms) const {
234  BlockedMultiVector::norm2(norms);
235 }
236 
237 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
238 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
239  normInf(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>& norms) const {
240  BlockedMultiVector::normInf(norms);
241 }
242 
243 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
244 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
245  meanValue(const Teuchos::ArrayView<Scalar>& /* means */) const {
246  throw Xpetra::Exceptions::RuntimeError("BlockedVector::meanValue: Not (yet) supported by BlockedVector.");
247 }
248 
249 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
250 Scalar
251 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
252  meanValue() const {
253  throw Xpetra::Exceptions::RuntimeError("BlockedVector::meanValue: Not (yet) supported by BlockedVector.");
254 }
255 
256 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
257 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
258  multiply(Teuchos::ETransp /* transA */,
259  Teuchos::ETransp /* transB */,
260  const Scalar& /* alpha */,
261  const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* A */,
262  const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* B */,
263  const Scalar& /* beta */) {
264  throw Xpetra::Exceptions::RuntimeError("BlockedVector::multiply: Not (yet) supported by BlockedVector.");
265 }
266 
267 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
268 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
269  multiply(Teuchos::ETransp /* transA */,
270  Teuchos::ETransp /* transB */,
271  const Scalar& /* alpha */,
272  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* A */,
273  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* B */,
274  const Scalar& /* beta */) {
275  throw Xpetra::Exceptions::RuntimeError("BlockedVector::multiply: Not (yet) supported by BlockedVector.");
276 }
277 
278 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
279 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
280  elementWiseMultiply(Scalar /* scalarAB */,
281  const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* A */,
282  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* B */,
283  Scalar /* scalarThis */) {
284  throw Xpetra::Exceptions::RuntimeError("BlockedVector::elementWiseMultiply: Not (yet) supported by BlockedVector.");
285 }
286 
287 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
288 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
289  elementWiseMultiply(Scalar /* scalarAB */,
290  const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A,
291  const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& B,
292  Scalar /* scalarThis */) {
293  XPETRA_TEST_FOR_EXCEPTION(B.getMap()->isSameAs(*(this->getMap())) == false,
294  Xpetra::Exceptions::RuntimeError,
295  "BlockedVector::elementWiseMultipy: B must have same blocked map than this.");
296  TEUCHOS_TEST_FOR_EXCEPTION(A.getMap()->getLocalNumElements() != B.getMap()->getLocalNumElements(),
297  Xpetra::Exceptions::RuntimeError,
298  "BlockedVector::elementWiseMultipy: A has "
299  << A.getMap()->getLocalNumElements() << " elements, B has " << B.getMap()->getLocalNumElements()
300  << ".");
301  TEUCHOS_TEST_FOR_EXCEPTION(A.getMap()->getGlobalNumElements() != B.getMap()->getGlobalNumElements(),
302  Xpetra::Exceptions::RuntimeError,
303  "BlockedVector::elementWiseMultipy: A has " << A.getMap()->getGlobalNumElements()
304  << " elements, B has "
305  << B.getMap()->getGlobalNumElements() << ".");
306 
307  RCP<const BlockedMap> bmap = this->getBlockedMap();
308  RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> rcpA = Teuchos::rcpFromRef(A);
309  RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> bmvec = Teuchos::rcpFromRef(B);
310  RCP<const BlockedVector> bbmvec = Teuchos::rcp_dynamic_cast<const BlockedVector>(bmvec);
311  TEUCHOS_TEST_FOR_EXCEPTION(bbmvec.is_null() == true,
312  Xpetra::Exceptions::RuntimeError,
313  "BlockedVector::elementWiseMultipy: B must be a BlockedVector.");
314 
315  // TODO implement me
316  /*RCP<Xpetra::MapExtractor<Scalar,LocalOrdinal,GlobalOrdinal,Node> > me = Teuchos::rcp(new
317  Xpetra::MapExtractor<Scalar,LocalOrdinal,GlobalOrdinal,Node>(bmap));
318 
319  for(size_t m = 0; m < bmap->getNumMaps(); m++) {
320  // TODO introduce BlockedVector objects and "skip" this expensive ExtractVector call
321  RCP<const Xpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> > pd = me->ExtractVector(rcpA,m,bmap->getThyraMode());
322  XPETRA_TEST_FOR_EXCEPTION(pd->getMap()->isSameAs(*(this->getBlockedMap()->getMap(m,bmap->getThyraMode())))==false,
323  Xpetra::Exceptions::RuntimeError, "BlockedVector::elementWiseMultipy: sub map of B does not fit with sub map of this.");
324  this->getMultiVector(m,bmap->getThyraMode())->elementWiseMultiply(scalarAB,*pd,*(bbmvec->getMultiVector(m,bmap->getThyraMode())),scalarThis);
325  }*/
326 }
327 
328 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
329 size_t
330 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
331  getNumVectors() const {
332  return 1;
333 }
334 
335 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
336 size_t
337 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
338  getLocalLength() const {
339  throw Xpetra::Exceptions::RuntimeError(
340  "BlockedVector::getLocalLength: routine not implemented. It has no value as one must iterate on the partial vectors.");
341  TEUCHOS_UNREACHABLE_RETURN(0);
342 }
343 
344 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
345 global_size_t
346 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
347  getGlobalLength() const {
348  return this->getBlockedMap()->getFullMap()->getGlobalNumElements();
349 }
350 
351 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
352 bool BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
353  isSameSize(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* vec */) const {
354  throw Xpetra::Exceptions::RuntimeError(
355  "BlockedVector::isSameSize: routine not implemented. It has no value as one must iterate on the partial vectors.");
356  TEUCHOS_UNREACHABLE_RETURN(0);
357 }
358 
359 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
360 std::string
361 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
362  description() const {
363  return std::string("BlockedVector");
364 }
365 
366 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
367 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
368  describe(Teuchos::FancyOStream& out, const Teuchos::EVerbosityLevel verbLevel) const {
369  out << description() << std::endl;
370  for (size_t r = 0; r < this->getBlockedMap()->getNumMaps(); r++) {
371  getMultiVector(r)->describe(out, verbLevel);
372  }
373 }
374 
375 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
376 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
377  replaceMap(const RCP<const Map>& map) {
378  BlockedMultiVector::replaceMap(map);
379 }
380 
381 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
382 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
383  doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* source */,
384  const Import& /* importer */,
385  CombineMode /* CM */) {
386  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doImport: Not supported by BlockedVector.");
387 }
388 
389 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
390 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
391  doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* dest */,
392  const Import& /* importer */,
393  CombineMode /* CM */) {
394  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doExport: Not supported by BlockedVector.");
395 }
396 
397 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
398 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
399  doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* source */,
400  const Export& /* exporter */,
401  CombineMode /* CM */) {
402  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doImport: Not supported by BlockedVector.");
403 }
404 
405 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
406 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
407  doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* dest */,
408  const Export& /* exporter */,
409  CombineMode /* CM */) {
410  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doExport: Not supported by BlockedVector.");
411 }
412 
413 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
414 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
415  setSeed(unsigned int seed) {
416  for (size_t r = 0; r < this->getBlockedMap()->getNumMaps(); ++r) {
417  getMultiVector(r)->setSeed(seed);
418  }
419 }
420 
421 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
422 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
423  randomize(bool bUseXpetraImplementation) {
424  for (size_t r = 0; r < this->getBlockedMap()->getNumMaps(); ++r) {
425  getMultiVector(r)->randomize(bUseXpetraImplementation);
426  }
427 }
428 
429 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
430 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
431  randomize(const Scalar& minVal, const Scalar& maxVal, bool bUseXpetraImplementation) {
432  for (size_t r = 0; r < this->getBlockedMap()->getNumMaps(); ++r) {
433  getMultiVector(r)->randomize(minVal, maxVal, bUseXpetraImplementation);
434  }
435 }
436 
437 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
438 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
439  Xpetra_randomize() {
440  {
441  Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Xpetra_randomize();
442  }
443 }
444 
445 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
446 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
447  Xpetra_randomize(const Scalar& minVal, const Scalar& maxVal) {
448  {
449  Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Xpetra_randomize(minVal, maxVal);
450  }
451 }
452 
453 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
454 Teuchos::RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>
455 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
456  getMap() const {
457  XPETRA_MONITOR("BlockedVector::getMap");
458  return this->getBlockedMap();
459 }
460 
461 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
462 Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
463 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
464  getMultiVector(size_t r) const {
465  return BlockedMultiVector::getMultiVector(r);
466 }
467 
468 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
469 Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
470 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
471  getMultiVector(size_t r, bool bThyraMode) const {
472  return BlockedMultiVector::getMultiVector(r, bThyraMode);
473 }
474 
475 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
476 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
477  setMultiVector(size_t r,
478  Teuchos::RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> v,
479  bool bThyraMode) {
480  BlockedMultiVector::setMultiVector(r, v, bThyraMode);
481  return;
482 }
483 
484 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
485 Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
486 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
487  Merge() const {
488  return BlockedMultiVector::Merge();
489 }
490 
491 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
492 void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
493  assign(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& rhs) {
494  BlockedMultiVector::assign(rhs);
495 }
496 
497 // template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
498 // virtual void BlockedVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>::
499 // assign (const XpetrA::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& rhs)
500 // {
501 // throw Xpetra::Exceptions::RuntimeError("BlockedVector::assign: Not supported by BlockedVector.");
502 // }
503 
504 } // namespace Xpetra
505 
506 #endif // XPETRA_BLOCKEDVECTOR_DEF_HPP
Xpetra::BlockedVector::getVectorNonConst
virtual Teuchos::RCP< Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getVectorNonConst(size_t j)
Return a Vector which is a nonconst view of column j.
Definition: Xpetra_BlockedVector_def.hpp:113
Xpetra::BlockedMultiVector::reciprocal
virtual void reciprocal(const MultiVector &)
Put element-wise reciprocal values of input Multi-vector in target, this(i,j) = 1/A(i,j).
Definition: Xpetra_BlockedMultiVector_def.hpp:236
Xpetra::BlockedVector::meanValue
virtual Scalar meanValue() const
Compute mean (average) value of this Vector.
Definition: Xpetra_BlockedVector_def.hpp:252
Xpetra::BlockedVector::setMultiVector
void setMultiVector(size_t r, Teuchos::RCP< const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node >> v, bool bThyraMode)
set partial Vector associated with block row r
Definition: Xpetra_BlockedVector_def.hpp:477
Xpetra::BlockedVector::setSeed
virtual void setSeed(unsigned int seed)
Set seed for Random function.
Definition: Xpetra_BlockedVector_def.hpp:415
Xpetra::BlockedVector::multiply
virtual void multiply(Teuchos::ETransp, Teuchos::ETransp, const Scalar &, const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Scalar &)
Matrix-matrix multiplication: this = beta*this + alpha*op(A)*op(B).
Definition: Xpetra_BlockedVector_def.hpp:258
Xpetra::BlockedVector::sumIntoLocalValue
virtual void sumIntoLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value)
Add value to existing value, using local (row) index.
Definition: Xpetra_BlockedVector_def.hpp:69
Xpetra::BlockedVector::update
virtual void update(const Scalar &alpha, const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &A, const Scalar &beta)
Update multi-vector values with scaled values of A, this = beta*this + alpha*A.
Definition: Xpetra_BlockedVector_def.hpp:177
Xpetra::BlockedMultiVector::getVector
virtual Teuchos::RCP< const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getVector(size_t j) const
Return a Vector which is a const view of column j.
Definition: Xpetra_BlockedMultiVector_def.hpp:179
Xpetra::BlockedMultiVector::sumIntoGlobalValue
virtual void sumIntoGlobalValue(GlobalOrdinal, size_t, const Scalar &)
Add value to existing value, using global (row) index.
Definition: Xpetra_BlockedMultiVector_def.hpp:151
Xpetra::BlockedVector::getVector
virtual Teuchos::RCP< const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getVector(size_t j) const
Return a Vector which is a const view of column j.
Definition: Xpetra_BlockedVector_def.hpp:106
Xpetra::BlockedVector::elementWiseMultiply
virtual void elementWiseMultiply(Scalar, const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, Scalar)
Element-wise multiply of a Vector A with a MultiVector B.
Definition: Xpetra_BlockedVector_def.hpp:280
Xpetra::BlockedVector::scale
virtual void scale(const Scalar &alpha)
Scale the current values of a vector, this = alpha*this.
Definition: Xpetra_BlockedVector_def.hpp:163
Xpetra::BlockedVector::replaceMap
virtual void replaceMap(const RCP< const Map > &map)
Definition: Xpetra_BlockedVector_def.hpp:377
Xpetra::BlockedVector::getNumVectors
virtual size_t getNumVectors() const
Number of columns in the Vector.
Definition: Xpetra_BlockedVector_def.hpp:331
Xpetra::BlockedMultiVector::getVectorNonConst
virtual Teuchos::RCP< Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getVectorNonConst(size_t j)
Return a Vector which is a nonconst view of column j.
Definition: Xpetra_BlockedMultiVector_def.hpp:194
Xpetra::BlockedMultiVector::replaceGlobalValue
virtual void replaceGlobalValue(GlobalOrdinal, size_t, const Scalar &)
Replace value, using global (row) index.
Definition: Xpetra_BlockedMultiVector_def.hpp:145
Xpetra::BlockedVector::description
virtual std::string description() const
A simple one-line description of this object.
Definition: Xpetra_BlockedVector_def.hpp:362
Xpetra::Exceptions::RuntimeError
Exception throws to report errors in the internal logical of the program.
Definition: Xpetra_Exceptions.hpp:65
Xpetra::MultiVector::Xpetra_randomize
virtual void Xpetra_randomize()
Set multi-vector values to random numbers. XPetra implementation.
Definition: Xpetra_MultiVector_def.hpp:32
Xpetra::BlockedVector::abs
virtual void abs(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &A)
Put element-wise absolute values of input vector in target: A = abs(this).
Definition: Xpetra_BlockedVector_def.hpp:149
Xpetra::BlockedMultiVector::sumIntoLocalValue
virtual void sumIntoLocalValue(LocalOrdinal, size_t, const Scalar &)
Add value to existing value, using local (row) index.
Definition: Xpetra_BlockedMultiVector_def.hpp:163
Xpetra::BlockedVector::dot
virtual void dot(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &A, const Teuchos::ArrayView< Scalar > &dots) const
Compute dot product of each corresponding pair of vectors, dots[i] = this[i].dot(A[i]).
Definition: Xpetra_BlockedVector_def.hpp:133
Xpetra::BlockedMultiVector::update
virtual void update(const Scalar &alpha, const MultiVector &A, const Scalar &beta)
Update multi-vector values with scaled values of A, this = beta*this + alpha*A.
Definition: Xpetra_BlockedMultiVector_def.hpp:264
Xpetra::BlockedMultiVector::replaceLocalValue
virtual void replaceLocalValue(LocalOrdinal, size_t, const Scalar &)
Replace value, using local (row) index.
Definition: Xpetra_BlockedMultiVector_def.hpp:157
Xpetra::BlockedVector::describe
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel=Teuchos::Describable::verbLevel_default) const
Print the object with the given verbosity level to a FancyOStream.
Definition: Xpetra_BlockedVector_def.hpp:368
Xpetra::BlockedMultiVector::Merge
Teuchos::RCP< MultiVector > Merge() const
merge BlockedMultiVector blocks to a single MultiVector
Definition: Xpetra_BlockedMultiVector_def.hpp:731
Xpetra::BlockedVector::reciprocal
virtual void reciprocal(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &A)
Put element-wise reciprocal values of input vector in target, this(i,j) = 1/A(i,j).
Definition: Xpetra_BlockedVector_def.hpp:156
Xpetra::BlockedMultiVector::norm2
virtual void norm2(const Teuchos::ArrayView< typename Teuchos::ScalarTraits< Scalar >::magnitudeType > &norms) const
Definition: Xpetra_BlockedMultiVector_def.hpp:413
Xpetra::BlockedVector::isSameSize
virtual bool isSameSize(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &) const
Local number of rows on the calling process.
Definition: Xpetra_BlockedVector_def.hpp:353
Xpetra_BlockedVector_decl.hpp
Xpetra::BlockedVector::assign
virtual void assign(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &rhs)
Implementation of the assignment operator (operator=); does a deep copy.
Definition: Xpetra_BlockedVector_def.hpp:493
Xpetra::BlockedMultiVector::replaceMap
virtual void replaceMap(const RCP< const Map > &map)
Definition: Xpetra_BlockedMultiVector_def.hpp:566
Xpetra::BlockedVector::getMap
Teuchos::RCP< const Map > getMap() const
Access function for the underlying Map this DistObject was constructed with.
Definition: Xpetra_BlockedVector_def.hpp:456
Xpetra::BlockedVector::getLocalLength
virtual size_t getLocalLength() const
Local number of rows on the calling process.
Definition: Xpetra_BlockedVector_def.hpp:338
Xpetra::DistObject< Scalar, LocalOrdinal, GlobalOrdinal, Node >::getMap
virtual Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > getMap() const =0
The Map describing the parallel distribution of this object.
Xpetra::BlockedVector::randomize
virtual void randomize(bool bUseXpetraImplementation=false)
Set multi-vector values to random numbers.
Definition: Xpetra_BlockedVector_def.hpp:423
Xpetra::BlockedMultiVector::scale
virtual void scale(const Scalar &alpha)
Scale the current values of a multi-vector, this = alpha*this.
Definition: Xpetra_BlockedMultiVector_def.hpp:242
Xpetra::BlockedVector::~BlockedVector
virtual ~BlockedVector()
Destructor.
Definition: Xpetra_BlockedVector_def.hpp:39
Xpetra::BlockedVector::norm2
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType norm2() const
Compute 2-norm of vector.
Definition: Xpetra_BlockedVector_def.hpp:208
Xpetra::BlockedMultiVector::setMultiVector
void setMultiVector(size_t r, Teuchos::RCP< const MultiVector > v, bool bThyraMode)
set partial multivector associated with block row r
Definition: Xpetra_BlockedMultiVector_def.hpp:705
Xpetra::BlockedMultiVector::norm1
virtual void norm1(const Teuchos::ArrayView< typename Teuchos::ScalarTraits< Scalar >::magnitudeType > &norms) const
Compute 1-norm of each vector in multi-vector.
Definition: Xpetra_BlockedMultiVector_def.hpp:396
Xpetra_Exceptions.hpp
Xpetra::BlockedMultiVector::normInf
virtual void normInf(const Teuchos::ArrayView< typename Teuchos::ScalarTraits< Scalar >::magnitudeType > &norms) const
Compute Inf-norm of each vector in multi-vector.
Definition: Xpetra_BlockedMultiVector_def.hpp:434
Xpetra::global_size_t
size_t global_size_t
Global size_t object.
Definition: Xpetra_ConfigDefs.hpp:138
Xpetra::BlockedMultiVector::getData
virtual Teuchos::ArrayRCP< const Scalar > getData(size_t j) const
Const view of the local values in a particular vector of this multivector.
Definition: Xpetra_BlockedMultiVector_def.hpp:203
Xpetra::BlockedMultiVector::abs
virtual void abs(const MultiVector &)
Put element-wise absolute values of input Multi-vector in target: A = abs(this).
Definition: Xpetra_BlockedMultiVector_def.hpp:230
Xpetra::BlockedVector::BlockedVector
BlockedVector(const Teuchos::RCP< const BlockedMap > &map, bool zeroOut=true)
Constructor.
Xpetra::BlockedMultiVector::dot
virtual void dot(const MultiVector &, const Teuchos::ArrayView< Scalar > &) const
Compute dot product of each corresponding pair of vectors, dots[i] = this[i].dot(A[i]).
Definition: Xpetra_BlockedMultiVector_def.hpp:224
Xpetra::BlockedMultiVector::getMultiVector
Teuchos::RCP< MultiVector > getMultiVector(size_t r) const
return partial multivector associated with block row r
Definition: Xpetra_BlockedMultiVector_def.hpp:679
Xpetra::BlockedMultiVector::assign
virtual void assign(const MultiVector &rhs)
Implementation of the assignment operator (operator=); does a deep copy.
Definition: Xpetra_BlockedMultiVector_def.hpp:754
Xpetra::BlockedVector::Merge
Teuchos::RCP< Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Merge() const
merge BlockedVector blocks to a single Vector
Definition: Xpetra_BlockedVector_def.hpp:487
Xpetra::BlockedMultiVector::getDataNonConst
virtual Teuchos::ArrayRCP< Scalar > getDataNonConst(size_t j)
View of the local values in a particular vector of this multivector.
Definition: Xpetra_BlockedMultiVector_def.hpp:214
Xpetra::BlockedVector::getData
virtual Teuchos::ArrayRCP< const Scalar > getData(size_t j) const
Const view of the local values in a particular vector of this vector.
Definition: Xpetra_BlockedVector_def.hpp:120
XPETRA_TEST_FOR_EXCEPTION
#define XPETRA_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Definition: Xpetra_ConfigDefs.hpp:107
Xpetra::BlockedVector::norm1
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType norm1() const
Compute 1-norm of vector.
Definition: Xpetra_BlockedVector_def.hpp:198
Xpetra::BlockedMultiVector::putScalar
virtual void putScalar(const Scalar &value)
Set all values in the multivector with the given value.
Definition: Xpetra_BlockedMultiVector_def.hpp:169
Xpetra::BlockedVector::getDataNonConst
virtual Teuchos::ArrayRCP< Scalar > getDataNonConst(size_t j)
View of the local values in a particular vector of this vector.
Definition: Xpetra_BlockedVector_def.hpp:127
Xpetra::BlockedVector::getGlobalLength
virtual global_size_t getGlobalLength() const
Global number of rows in the Vector.
Definition: Xpetra_BlockedVector_def.hpp:347
Xpetra::BlockedVector::replaceGlobalValue
virtual void replaceGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value)
Replace value, using global (row) index.
Definition: Xpetra_BlockedVector_def.hpp:51
Xpetra::BlockedVector::operator=
BlockedVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > & operator=(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &rhs)
Assignment operator: Does a deep copy.
Definition: Xpetra_BlockedVector_def.hpp:44
Xpetra::CombineMode
CombineMode
Xpetra::Combine Mode enumerable type.
Definition: Xpetra_ConfigDefs.hpp:176
XPETRA_MONITOR
#define XPETRA_MONITOR(funcName)
Definition: Xpetra_ConfigDefs.hpp:96
Xpetra::BlockedVector::sumIntoGlobalValue
virtual void sumIntoGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value)
Add value to existing value, using global (row) index.
Definition: Xpetra_BlockedVector_def.hpp:57
Xpetra::BlockedVector::normInf
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType normInf() const
Compute Inf-norm in vector.
Definition: Xpetra_BlockedVector_def.hpp:218
Xpetra::BlockedVector::doImport
virtual void doImport(const DistObject< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Import &, CombineMode)
Import.
Definition: Xpetra_BlockedVector_def.hpp:383
Xpetra::BlockedVector::doExport
virtual void doExport(const DistObject< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Import &, CombineMode)
Export.
Definition: Xpetra_BlockedVector_def.hpp:391
Xpetra::BlockedVector::putScalar
virtual void putScalar(const Scalar &value)
Set all values in the vector with the given value.
Definition: Xpetra_BlockedVector_def.hpp:99
Xpetra::BlockedVector::Xpetra_randomize
virtual void Xpetra_randomize()
Set vector values to random numbers. XPetra implementation.
Definition: Xpetra_BlockedVector_def.hpp:439
Xpetra::BlockedVector::getMultiVector
Teuchos::RCP< Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getMultiVector(size_t r) const
return partial Vector associated with block row r
Definition: Xpetra_BlockedVector_def.hpp:464
Xpetra::BlockedVector::replaceLocalValue
virtual void replaceLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value)
Replace value, using local (row) index.
Definition: Xpetra_BlockedVector_def.hpp:63