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 // ***********************************************************************
4 //
5 // Xpetra: A linear algebra interface package
6 // Copyright 2012 Sandia Corporation
7 //
8 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9 // the U.S. Government retains certain rights in this software.
10 //
11 // Redistribution and use in source and binary forms, with or without
12 // modification, are permitted provided that the following conditions are
13 // met:
14 //
15 // 1. Redistributions of source code must retain the above copyright
16 // notice, this list of conditions and the following disclaimer.
17 //
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 //
22 // 3. Neither the name of the Corporation nor the names of the
23 // contributors may be used to endorse or promote products derived from
24 // this software without specific prior written permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 //
38 // Questions? Contact
39 // Jonathan Hu (jhu@sandia.gov)
40 // Andrey Prokopenko (aprokop@sandia.gov)
41 // Tobias Wiesner (tawiesn@sandia.gov)
42 // Ray Tuminaro (rstumin@sandia.gov)
43 //
44 // ***********************************************************************
45 //
46 // @HEADER
47 #ifndef XPETRA_BLOCKEDVECTOR_DEF_HPP
48 #define XPETRA_BLOCKEDVECTOR_DEF_HPP
49 
50 #include "Xpetra_BlockedVector_decl.hpp"
51 
52 #include "Xpetra_BlockedMultiVector.hpp"
53 #include "Xpetra_Exceptions.hpp"
54 
55 
56 
57 namespace Xpetra {
58 
59 
60 
61 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
62 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
63 BlockedVector(const Teuchos::RCP<const Xpetra::BlockedMap<LocalOrdinal,GlobalOrdinal,Node>>& map, bool zeroOut)
64  : Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(map, 1, zeroOut)
65 { }
66 
67 
68 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
69 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
70 BlockedVector( Teuchos::RCP<const Xpetra::BlockedMap<LocalOrdinal,GlobalOrdinal,Node>> bmap,
71  Teuchos::RCP<Xpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node>> v)
72  : Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(bmap, v)
73 { }
74 
75 
76 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
77 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
78 BlockedVector( Teuchos::RCP<const Xpetra::MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node> > mapExtractor,
79  Teuchos::RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v)
80  : Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(mapExtractor, v)
81 { }
82 
83 
84 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
85 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
86 ~BlockedVector()
87 { }
88 
89 
90 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
91 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>&
92 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
93 operator=(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& rhs)
94 {
95  assign(rhs); // dispatch to protected virtual method
96  return *this;
97 }
98 
99 
100 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
101 void
102 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
103 replaceGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar& value)
104 {
105  BlockedMultiVector::replaceGlobalValue(globalRow, vectorIndex, value);
106 }
107 
108 
109 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
110 void
111 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
112 sumIntoGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar& value)
113 {
114  BlockedMultiVector::sumIntoGlobalValue(globalRow, vectorIndex, value);
115 }
116 
117 
118 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
119 void
120 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
121 replaceLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar& value)
122 {
123  BlockedMultiVector::replaceLocalValue(myRow, vectorIndex, value);
124 }
125 
126 
127 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
128 void
129 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
130 sumIntoLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar& value)
131 {
132  BlockedMultiVector::sumIntoLocalValue(myRow, vectorIndex, value);
133 }
134 
135 
136 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
137 void
138 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
139 replaceGlobalValue(GlobalOrdinal globalRow, const Scalar& value)
140 {
141  BlockedMultiVector::replaceGlobalValue(globalRow, 0, value);
142 }
143 
144 
145 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
146 void
147 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
148 sumIntoGlobalValue(GlobalOrdinal globalRow, const Scalar& value)
149 {
150  BlockedMultiVector::sumIntoGlobalValue(globalRow, 0, value);
151 }
152 
153 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
154 void
155 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
156 replaceLocalValue(LocalOrdinal myRow, const Scalar& value)
157 {
158  BlockedMultiVector::replaceLocalValue(myRow, 0, value);
159 }
160 
161 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
162 void
163 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
164 sumIntoLocalValue(LocalOrdinal myRow, const Scalar& value)
165 {
166  BlockedMultiVector::sumIntoLocalValue(myRow, 0, value);
167 }
168 
169 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
170 void
171 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
172 putScalar(const Scalar& value)
173 {
174  BlockedMultiVector::putScalar(value);
175 }
176 
177 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
178 Teuchos::RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
179 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
180 getVector(size_t j) const
181 {
182  return BlockedMultiVector::getVector(j);
183 }
184 
185 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
186 Teuchos::RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
187 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
188 getVectorNonConst(size_t j)
189 {
190  return BlockedMultiVector::getVectorNonConst(j);
191 }
192 
193 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
194 Teuchos::ArrayRCP<const Scalar>
195 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
196 getData(size_t j) const
197 {
198  return BlockedMultiVector::getData(j);
199 }
200 
201 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
202 Teuchos::ArrayRCP<Scalar>
203 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
204 getDataNonConst(size_t j)
205 {
206  return BlockedMultiVector::getDataNonConst(j);
207 }
208 
209 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
210 void
211 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
212 dot(const MultiVector& A, const Teuchos::ArrayView<Scalar>& dots) const
213 {
214  BlockedMultiVector::dot(A, dots);
215  return;
216 }
217 
218 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
219 Scalar
220 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
221 dot(const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A) const
222 {
223  Teuchos::Array<Scalar> dots = Teuchos::Array<Scalar>(1);
224  BlockedMultiVector::dot(A, dots);
225  return dots[ 0 ];
226 }
227 
228 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
229 void
230 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
231 abs(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A)
232 {
233  BlockedMultiVector::abs(A);
234  return;
235 }
236 
237 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
238 void
239 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
240 reciprocal(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A)
241 {
242  BlockedMultiVector::reciprocal(A);
243  return;
244 }
245 
246 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
247 void
248 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
249 scale(const Scalar& alpha)
250 {
251  BlockedMultiVector::scale(alpha);
252  return;
253 }
254 
255 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
256 void
257 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
258 scale(Teuchos::ArrayView<const Scalar> alpha)
259 {
260  BlockedMultiVector::scale(alpha);
261  return;
262 }
263 
264 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
265 void
266 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
267 update(const Scalar& alpha,
268  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A,
269  const Scalar& beta)
270 {
271  BlockedMultiVector::update(alpha, A, beta);
272  return;
273 }
274 
275 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
276 void
277 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
278 update(const Scalar& alpha,
279  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A,
280  const Scalar& beta,
281  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& B,
282  const Scalar& gamma)
283 {
284  BlockedMultiVector::update(alpha, A, beta, B, gamma);
285  return;
286 }
287 
288 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
289 typename Teuchos::ScalarTraits<Scalar>::magnitudeType
290 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
291 norm1() const
292 {
293  using Array = Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>;
294  Array norm = Array(1);
295  this->norm1(norm);
296  return norm[ 0 ];
297 }
298 
299 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
300 typename Teuchos::ScalarTraits<Scalar>::magnitudeType
301 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
302 norm2() const
303 {
304  Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> norm =
305  Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>(1);
306  this->norm2(norm);
307  return norm[ 0 ];
308 }
309 
310 
311 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
312 typename Teuchos::ScalarTraits<Scalar>::magnitudeType
313 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
314 normInf() const
315 {
316  Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>
317  norm = Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>(1);
318  this->normInf(norm);
319  return norm[ 0 ];
320 }
321 
322 
323 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
324 void
325 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
326 norm1(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>& norms) const
327 {
328  BlockedMultiVector::norm1(norms);
329 }
330 
331 
332 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
333 void
334 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
335 norm2(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>& norms) const
336 {
337  BlockedMultiVector::norm2(norms);
338 }
339 
340 
341 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
342 void
343 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
344 normInf(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>& norms) const
345 {
346  BlockedMultiVector::normInf(norms);
347 }
348 
349 
350 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
351 void
352 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
353 meanValue(const Teuchos::ArrayView<Scalar>& /* means */) const
354 {
355  throw Xpetra::Exceptions::RuntimeError("BlockedVector::meanValue: Not (yet) supported by BlockedVector.");
356 }
357 
358 
359 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
360 Scalar
361 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
362 meanValue() const
363 {
364  throw Xpetra::Exceptions::RuntimeError("BlockedVector::meanValue: Not (yet) supported by BlockedVector.");
365 }
366 
367 
368 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
369 void
370 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
371 multiply(Teuchos::ETransp /* transA */,
372  Teuchos::ETransp /* transB */,
373  const Scalar& /* alpha */,
374  const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* A */,
375  const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* B */,
376  const Scalar& /* beta */)
377 {
378  throw Xpetra::Exceptions::RuntimeError("BlockedVector::multiply: Not (yet) supported by BlockedVector.");
379 }
380 
381 
382 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
383 void
384 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
385 multiply(Teuchos::ETransp /* transA */,
386  Teuchos::ETransp /* transB */,
387  const Scalar& /* alpha */,
388  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* A */,
389  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* B */,
390  const Scalar& /* beta */)
391 {
392  throw Xpetra::Exceptions::RuntimeError("BlockedVector::multiply: Not (yet) supported by BlockedVector.");
393 }
394 
395 
396 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
397 void
398 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
399 elementWiseMultiply( Scalar /* scalarAB */,
400  const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* A */,
401  const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* B */,
402  Scalar /* scalarThis */)
403 {
404  throw Xpetra::Exceptions::RuntimeError("BlockedVector::elementWiseMultiply: Not (yet) supported by BlockedVector.");
405 }
406 
407 
408 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
409 void
410 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
411 elementWiseMultiply( Scalar /* scalarAB */,
412  const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A,
413  const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& B,
414  Scalar /* scalarThis */)
415 {
416  XPETRA_TEST_FOR_EXCEPTION(B.getMap()->isSameAs(*(this->getMap())) == false,
417  Xpetra::Exceptions::RuntimeError,
418  "BlockedVector::elementWiseMultipy: B must have same blocked map than this.");
419  TEUCHOS_TEST_FOR_EXCEPTION(A.getMap()->getNodeNumElements() != B.getMap()->getNodeNumElements(),
420  Xpetra::Exceptions::RuntimeError,
421  "BlockedVector::elementWiseMultipy: A has "
422  << A.getMap()->getNodeNumElements() << " elements, B has " << B.getMap()->getNodeNumElements()
423  << ".");
424  TEUCHOS_TEST_FOR_EXCEPTION(A.getMap()->getGlobalNumElements() != B.getMap()->getGlobalNumElements(),
425  Xpetra::Exceptions::RuntimeError,
426  "BlockedVector::elementWiseMultipy: A has " << A.getMap()->getGlobalNumElements()
427  << " elements, B has "
428  << B.getMap()->getGlobalNumElements() << ".");
429 
430  RCP<const BlockedMap> bmap = this->getBlockedMap();
431  RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> rcpA = Teuchos::rcpFromRef(A);
432  RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> bmvec = Teuchos::rcpFromRef(B);
433  RCP<const BlockedVector> bbmvec = Teuchos::rcp_dynamic_cast<const BlockedVector>(bmvec);
434  TEUCHOS_TEST_FOR_EXCEPTION(bbmvec.is_null() == true,
435  Xpetra::Exceptions::RuntimeError,
436  "BlockedVector::elementWiseMultipy: B must be a BlockedVector.");
437 
438  // TODO implement me
439  /*RCP<Xpetra::MapExtractor<Scalar,LocalOrdinal,GlobalOrdinal,Node> > me = Teuchos::rcp(new
440  Xpetra::MapExtractor<Scalar,LocalOrdinal,GlobalOrdinal,Node>(bmap));
441 
442  for(size_t m = 0; m < bmap->getNumMaps(); m++) {
443  // TODO introduce BlockedVector objects and "skip" this expensive ExtractVector call
444  RCP<const Xpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> > pd = me->ExtractVector(rcpA,m,bmap->getThyraMode());
445  XPETRA_TEST_FOR_EXCEPTION(pd->getMap()->isSameAs(*(this->getBlockedMap()->getMap(m,bmap->getThyraMode())))==false,
446  Xpetra::Exceptions::RuntimeError, "BlockedVector::elementWiseMultipy: sub map of B does not fit with sub map of this.");
447  this->getMultiVector(m,bmap->getThyraMode())->elementWiseMultiply(scalarAB,*pd,*(bbmvec->getMultiVector(m,bmap->getThyraMode())),scalarThis);
448  }*/
449 }
450 
451 
452 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
453 size_t
454 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
455 getNumVectors() const
456 {
457  return 1;
458 }
459 
460 
461 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
462 size_t
463 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
464 getLocalLength() const
465 {
466  throw Xpetra::Exceptions::RuntimeError(
467  "BlockedVector::getLocalLength: routine not implemented. It has no value as one must iterate on the partial vectors.");
468  TEUCHOS_UNREACHABLE_RETURN(0);
469 }
470 
471 
472 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
473 global_size_t
474 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
475 getGlobalLength() const
476 {
477  return this->getBlockedMap()->getFullMap()->getGlobalNumElements();
478 }
479 
480 
481 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
482 bool
483 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
484 isSameSize(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* vec */) const
485 {
486  throw Xpetra::Exceptions::RuntimeError(
487  "BlockedVector::isSameSize: routine not implemented. It has no value as one must iterate on the partial vectors.");
488  TEUCHOS_UNREACHABLE_RETURN(0);
489 }
490 
491 
492 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
493 std::string
494 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
495 description() const
496 {
497  return std::string("BlockedVector");
498 }
499 
500 
501 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
502 void
503 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
504 describe(Teuchos::FancyOStream& out, const Teuchos::EVerbosityLevel verbLevel) const
505 {
506  out << description() << std::endl;
507  for(size_t r = 0; r < this->getBlockedMap()->getNumMaps(); r++)
508  {
509  getMultiVector(r)->describe(out, verbLevel);
510  }
511 }
512 
513 
514 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
515 void
516 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
517 replaceMap(const RCP<const Map>& map)
518 {
519  BlockedMultiVector::replaceMap(map);
520 }
521 
522 
523 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
524 void
525 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
526 doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* source */,
527  const Import& /* importer */,
528  CombineMode /* CM */)
529 {
530  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doImport: Not supported by BlockedVector.");
531 }
532 
533 
534 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
535 void
536 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
537 doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* dest */,
538  const Import& /* importer */,
539  CombineMode /* CM */)
540 {
541  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doExport: Not supported by BlockedVector.");
542 }
543 
544 
545 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
546 void
547 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
548 doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* source */,
549  const Export& /* exporter */,
550  CombineMode /* CM */)
551 {
552  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doImport: Not supported by BlockedVector.");
553 }
554 
555 
556 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
557 void
558 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
559 doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* dest */,
560  const Export& /* exporter */,
561  CombineMode /* CM */)
562 {
563  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doExport: Not supported by BlockedVector.");
564 }
565 
566 
567 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
568 void
569 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
570 setSeed(unsigned int seed)
571 {
572  for(size_t r = 0; r < this->getBlockedMap()->getNumMaps(); ++r)
573  {
574  getMultiVector(r)->setSeed(seed);
575  }
576 }
577 
578 
579 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
580 void
581 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
582 randomize(bool bUseXpetraImplementation)
583 {
584  for(size_t r = 0; r < this->getBlockedMap()->getNumMaps(); ++r)
585  {
586  getMultiVector(r)->randomize(bUseXpetraImplementation);
587  }
588 }
589 
590 
591 template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
592 void
593 BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
594 Xpetra_randomize()
595 {
596  {
597  Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Xpetra_randomize();
598  }
599 }
600 
601 #ifdef HAVE_XPETRA_KOKKOS_REFACTOR
602 
603 #if 0
604  template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
605  template<class TargetDeviceType>
606  typename Kokkos::Impl::if_c<std::is_same<typename dev_execution_space::memory_space,
607  typename TargetDeviceType::memory_space>::value,
608  typename dual_view_type::t_dev_um,
609  typename dual_view_type::t_host_um>::type
610  BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
611  getLocalView() const
612  {
613  if(std::is_same<typename host_execution_space::memory_space, typename TargetDeviceType::memory_space>::value)
614  {
615  return getHostLocalView();
616  }
617  else
618  {
619  return getDeviceLocalView();
620  }
621  }
622 #endif
623 
624 // template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
625 // virtual typename dual_view_type::
626 // t_dev_um BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::getDeviceLocalView() const
627 // {
628 // typename dual_view_type::t_dev_um test;
629 // return test;
630 // }
631 #endif // HAVE_XPETRA_KOKKOS_REFACTOR
632 
633 
634  template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
635  Teuchos::RCP<const Xpetra::Map<LocalOrdinal,GlobalOrdinal,Node> >
636  BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
637  getMap() const
638  {
639  XPETRA_MONITOR("BlockedVector::getMap");
640  return this->getBlockedMap();
641  }
642 
643 
644  template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
645  Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> >
646  BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
647  getMultiVector(size_t r) const
648  {
649  return BlockedMultiVector::getMultiVector(r);
650  }
651 
652 
653  template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
654  Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> >
655  BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
656  getMultiVector(size_t r, bool bThyraMode) const
657  {
658  return BlockedMultiVector::getMultiVector(r, bThyraMode);
659  }
660 
661 
662  template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
663  void
664  BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
665  setMultiVector(size_t r,
666  Teuchos::RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v,
667  bool bThyraMode)
668  {
669  BlockedMultiVector::setMultiVector(r, v, bThyraMode);
670  return;
671  }
672 
673 
674  template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
675  Teuchos::RCP< Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> >
676  BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
677  Merge() const
678  {
679  return BlockedMultiVector::Merge();
680  }
681 
682 
683  template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
684  void
685  BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
686  assign(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& rhs)
687  {
688  BlockedMultiVector::assign(rhs);
689  }
690 
691 
692  // template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
693  // virtual void BlockedVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>::
694  // assign (const XpetrA::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& rhs)
695  // {
696  // throw Xpetra::Exceptions::RuntimeError("BlockedVector::assign: Not supported by BlockedVector.");
697  // }
698 
699 } // Xpetra namespace
700 
701 
702 #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:188
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:322
Xpetra::BlockedVector::meanValue
virtual Scalar meanValue() const
Compute mean (average) value of this Vector.
Definition: Xpetra_BlockedVector_def.hpp:362
Xpetra::BlockedVector::setSeed
virtual void setSeed(unsigned int seed)
Set seed for Random function.
Definition: Xpetra_BlockedVector_def.hpp:570
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:371
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:130
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:267
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:247
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:207
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:180
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:399
Xpetra::BlockedVector::scale
virtual void scale(const Scalar &alpha)
Scale the current values of a vector, this = alpha*this.
Definition: Xpetra_BlockedVector_def.hpp:249
Xpetra::BlockedVector::replaceMap
virtual void replaceMap(const RCP< const Map > &map)
Definition: Xpetra_BlockedVector_def.hpp:517
Xpetra::BlockedVector::getNumVectors
virtual size_t getNumVectors() const
Number of columns in the Vector.
Definition: Xpetra_BlockedVector_def.hpp:455
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:265
Xpetra::BlockedMultiVector::replaceGlobalValue
virtual void replaceGlobalValue(GlobalOrdinal, size_t, const Scalar &)
Replace value, using global (row) index.
Definition: Xpetra_BlockedMultiVector_def.hpp:198
Xpetra::BlockedVector::description
virtual std::string description() const
A simple one-line description of this object.
Definition: Xpetra_BlockedVector_def.hpp:495
Xpetra::Exceptions::RuntimeError
Exception throws to report errors in the internal logical of the program.
Definition: Xpetra_Exceptions.hpp:101
Xpetra::MultiVector::Xpetra_randomize
virtual void Xpetra_randomize()
Set multi-vector values to random numbers. XPetra implementation.
Definition: Xpetra_MultiVector_def.hpp:75
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:231
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:224
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:212
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:363
Xpetra::BlockedMultiVector::replaceLocalValue
virtual void replaceLocalValue(LocalOrdinal, size_t, const Scalar &)
Replace value, using local (row) index.
Definition: Xpetra_BlockedMultiVector_def.hpp:215
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:504
Xpetra::BlockedMultiVector::Merge
Teuchos::RCP< MultiVector > Merge() const
merge BlockedMultiVector blocks to a single MultiVector
Definition: Xpetra_BlockedMultiVector_def.hpp:915
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:240
Xpetra::BlockedMultiVector::norm2
virtual void norm2(const Teuchos::ArrayView< typename Teuchos::ScalarTraits< Scalar >::magnitudeType > &norms) const
Definition: Xpetra_BlockedMultiVector_def.hpp:537
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:484
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:686
Xpetra::BlockedMultiVector::replaceMap
virtual void replaceMap(const RCP< const Map > &map)
Definition: Xpetra_BlockedMultiVector_def.hpp:726
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:637
Xpetra::BlockedVector::getLocalLength
virtual size_t getLocalLength() const
Local number of rows on the calling process.
Definition: Xpetra_BlockedVector_def.hpp:464
Xpetra::BlockedVector::randomize
virtual void randomize(bool bUseXpetraImplementation=false)
Set multi-vector values to random numbers.
Definition: Xpetra_BlockedVector_def.hpp:582
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:331
Xpetra::BlockedVector::~BlockedVector
virtual ~BlockedVector()
Destructor.
Definition: Xpetra_BlockedVector_def.hpp:86
Xpetra::BlockedVector::norm2
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType norm2() const
Compute 2-norm of vector.
Definition: Xpetra_BlockedVector_def.hpp:302
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:665
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::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:887
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:514
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:563
Xpetra::global_size_t
size_t global_size_t
Global size_t object.
Definition: Xpetra_ConfigDefs.hpp:174
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:276
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:313
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:304
Xpetra::BlockedMultiVector::getMultiVector
Teuchos::RCP< MultiVector > getMultiVector(size_t r) const
return partial multivector associated with block row r
Definition: Xpetra_BlockedMultiVector_def.hpp:856
Xpetra::BlockedMultiVector::assign
virtual void assign(const MultiVector &rhs)
Implementation of the assignment operator (operator=); does a deep copy.
Definition: Xpetra_BlockedMultiVector_def.hpp:945
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:677
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:290
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:196
XPETRA_TEST_FOR_EXCEPTION
#define XPETRA_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Definition: Xpetra_ConfigDefs.hpp:143
Xpetra::BlockedVector::norm1
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType norm1() const
Compute 1-norm of vector.
Definition: Xpetra_BlockedVector_def.hpp:291
Xpetra::BlockedMultiVector::putScalar
virtual void putScalar(const Scalar &value)
Set all values in the multivector with the given value.
Definition: Xpetra_BlockedMultiVector_def.hpp:234
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:204
Xpetra::BlockedVector::getGlobalLength
virtual global_size_t getGlobalLength() const
Global number of rows in the Vector.
Definition: Xpetra_BlockedVector_def.hpp:475
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:103
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:93
Xpetra::CombineMode
CombineMode
Xpetra::Combine Mode enumerable type.
Definition: Xpetra_ConfigDefs.hpp:212
XPETRA_MONITOR
#define XPETRA_MONITOR(funcName)
Definition: Xpetra_ConfigDefs.hpp:132
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:112
Xpetra::BlockedVector::normInf
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType normInf() const
Compute Inf-norm in vector.
Definition: Xpetra_BlockedVector_def.hpp:314
Xpetra::BlockedVector::doImport
virtual void doImport(const DistObject< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Import &, CombineMode)
Import.
Definition: Xpetra_BlockedVector_def.hpp:526
Xpetra::BlockedVector::doExport
virtual void doExport(const DistObject< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Import &, CombineMode)
Export.
Definition: Xpetra_BlockedVector_def.hpp:537
Xpetra::BlockedVector::putScalar
virtual void putScalar(const Scalar &value)
Set all values in the vector with the given value.
Definition: Xpetra_BlockedVector_def.hpp:172
Xpetra::BlockedVector::Xpetra_randomize
virtual void Xpetra_randomize()
Set vector values to random numbers. XPetra implementation.
Definition: Xpetra_BlockedVector_def.hpp:594
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:647
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:121