Xpetra Version of the Day
Loading...
Searching...
No Matches
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
18namespace Xpetra {
19
20template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
21BlockedVector<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
25template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
30
31template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
32BlockedVector<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
37template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
40
41template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
42BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>&
48
49template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
50void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
51 replaceGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar& value) {
52 BlockedMultiVector::replaceGlobalValue(globalRow, vectorIndex, value);
53}
54
55template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
56void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
57 sumIntoGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar& value) {
58 BlockedMultiVector::sumIntoGlobalValue(globalRow, vectorIndex, value);
59}
60
61template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
62void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
63 replaceLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar& value) {
64 BlockedMultiVector::replaceLocalValue(myRow, vectorIndex, value);
65}
66
67template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
68void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
69 sumIntoLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar& value) {
70 BlockedMultiVector::sumIntoLocalValue(myRow, vectorIndex, value);
71}
72
73template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
74void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
75 replaceGlobalValue(GlobalOrdinal globalRow, const Scalar& value) {
76 BlockedMultiVector::replaceGlobalValue(globalRow, 0, value);
77}
78
79template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
80void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
81 sumIntoGlobalValue(GlobalOrdinal globalRow, const Scalar& value) {
82 BlockedMultiVector::sumIntoGlobalValue(globalRow, 0, value);
83}
84
85template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
86void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
87 replaceLocalValue(LocalOrdinal myRow, const Scalar& value) {
88 BlockedMultiVector::replaceLocalValue(myRow, 0, value);
89}
90
91template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
92void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
93 sumIntoLocalValue(LocalOrdinal myRow, const Scalar& value) {
94 BlockedMultiVector::sumIntoLocalValue(myRow, 0, value);
95}
96
97template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
98void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
99 putScalar(const Scalar& value) {
100 BlockedMultiVector::putScalar(value);
101}
102
103template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
104Teuchos::RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
105BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
106 getVector(size_t j) const {
107 return BlockedMultiVector::getVector(j);
108}
109
110template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
111Teuchos::RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
112BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
113 getVectorNonConst(size_t j) {
114 return BlockedMultiVector::getVectorNonConst(j);
115}
116
117template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
118Teuchos::ArrayRCP<const Scalar>
119BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
120 getData(size_t j) const {
121 return BlockedMultiVector::getData(j);
122}
123
124template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
125Teuchos::ArrayRCP<Scalar>
126BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
127 getDataNonConst(size_t j) {
128 return BlockedMultiVector::getDataNonConst(j);
129}
130
131template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
132void 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
138template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
139Scalar
146
147template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
153
154template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
160
161template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
162void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
163 scale(const Scalar& alpha) {
164 BlockedMultiVector::scale(alpha);
165 return;
166}
167
168template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
169void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
170 scale(Teuchos::ArrayView<const Scalar> alpha) {
171 BlockedMultiVector::scale(alpha);
172 return;
173}
174
175template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
176void 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
184template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
185void 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
195template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
196typename Teuchos::ScalarTraits<Scalar>::magnitudeType
204
205template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
206typename Teuchos::ScalarTraits<Scalar>::magnitudeType
214
215template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
216typename Teuchos::ScalarTraits<Scalar>::magnitudeType
224
225template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
226void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
227 norm1(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>& norms) const {
228 BlockedMultiVector::norm1(norms);
229}
230
231template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
232void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
233 norm2(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>& norms) const {
234 BlockedMultiVector::norm2(norms);
235}
236
237template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
238void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
239 normInf(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>& norms) const {
240 BlockedMultiVector::normInf(norms);
241}
242
243template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
244void 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
249template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
250Scalar
251BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
252 meanValue() const {
253 throw Xpetra::Exceptions::RuntimeError("BlockedVector::meanValue: Not (yet) supported by BlockedVector.");
254}
255
256template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
257void 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
267template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
268void 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
278template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
279void 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
287template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
288void 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
328template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
329size_t
334
335template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
336size_t
337BlockedVector<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
344template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
345global_size_t
346BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
347 getGlobalLength() const {
348 return this->getBlockedMap()->getFullMap()->getGlobalNumElements();
349}
350
351template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
352bool 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
359template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
360std::string
361BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
362 description() const {
363 return std::string("BlockedVector");
364}
365
366template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
367void 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
375template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
376void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
377 replaceMap(const RCP<const Map>& map) {
378 BlockedMultiVector::replaceMap(map);
379}
380
381template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
382void 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
389template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
390void 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
397template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
398void 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
405template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
406void 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
413template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
414void 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
421template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
422void 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
429template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
430void 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
437template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
444
445template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
452
453template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
454Teuchos::RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>
455BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
456 getMap() const {
457 XPETRA_MONITOR("BlockedVector::getMap");
458 return this->getBlockedMap();
459}
460
461template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
462Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
463BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
464 getMultiVector(size_t r) const {
465 return BlockedMultiVector::getMultiVector(r);
466}
467
468template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
469Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
470BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
471 getMultiVector(size_t r, bool bThyraMode) const {
472 return BlockedMultiVector::getMultiVector(r, bThyraMode);
473}
474
475template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
476void 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
484template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
485Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
486BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
487 Merge() const {
488 return BlockedMultiVector::Merge();
489}
490
491template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
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_MONITOR
#define XPETRA_MONITOR(funcName)
XPETRA_TEST_FOR_EXCEPTION
#define XPETRA_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Xpetra_BlockedVector_decl.hpp
Xpetra_Exceptions.hpp
Teuchos::RCP::is_null
bool is_null() const
Xpetra::BlockedMultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Tpetra::KokkosClassic::DefaultNode::DefaultNodeType >::getBlockedMap
Teuchos::RCP< const Xpetra::BlockedMap< LocalOrdinal, GlobalOrdinal, Tpetra::KokkosClassic::DefaultNode::DefaultNodeType > > getBlockedMap() const
Definition Xpetra_BlockedMultiVector_def.hpp:671
Xpetra::BlockedVector::description
virtual std::string description() const
A simple one-line description of this object.
Definition Xpetra_BlockedVector_def.hpp:362
Xpetra::BlockedVector::norm2
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType norm2() const
Compute 2-norm of vector.
Definition Xpetra_BlockedVector_def.hpp:208
Xpetra::BlockedVector::BlockedVector
BlockedVector(const Teuchos::RCP< const BlockedMap > &map, bool zeroOut=true)
Constructor.
Definition Xpetra_BlockedVector_def.hpp:22
Xpetra::BlockedVector::norm1
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType norm1() const
Compute 1-norm of vector.
Definition Xpetra_BlockedVector_def.hpp:198
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::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::normInf
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType normInf() const
Compute Inf-norm in vector.
Definition Xpetra_BlockedVector_def.hpp:218
Xpetra::DistObject::getMap
virtual Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > getMap() const =0
The Map describing the parallel distribution of this object.
Xpetra::Exceptions::RuntimeError
Exception throws to report errors in the internal logical of the program.
Definition Xpetra_Exceptions.hpp:57
TEUCHOS_TEST_FOR_EXCEPTION
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
TEUCHOS_UNREACHABLE_RETURN
#define TEUCHOS_UNREACHABLE_RETURN(dummyReturnVal)
Teuchos::FancyOStream
basic_FancyOStream< char > FancyOStream
Teuchos::EVerbosityLevel
EVerbosityLevel
Xpetra::global_size_t
size_t global_size_t
Global size_t object.
Definition Xpetra_ConfigDefs.hpp:136
Xpetra::CombineMode
CombineMode
Xpetra::Combine Mode enumerable type.
Definition Xpetra_ConfigDefs.hpp:174