Xpetra Version of the Day
Loading...
Searching...
No Matches
Xpetra_MapExtractor_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_MAPEXTRACTOR_DEF_HPP_
11#define XPETRA_MAPEXTRACTOR_DEF_HPP_
12
13#include <Xpetra_MultiVectorFactory.hpp>
14#include <Xpetra_VectorFactory.hpp>
15#include <Xpetra_BlockedMultiVector.hpp>
16
17#include <Xpetra_MapExtractor_decl.hpp>
18
19namespace Xpetra {
20
21template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
22MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
23 MapExtractor(const RCP<const Map>& fullmap, const std::vector<RCP<const Map>>& maps, bool bThyraMode) {
24 map_ = Teuchos::rcp(new BlockedMap(fullmap, maps, bThyraMode));
25}
26
27template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
28MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
29 MapExtractor(const std::vector<RCP<const Map>>& maps, const std::vector<RCP<const Map>>& thyramaps) {
30 map_ = Teuchos::rcp(new BlockedMap(maps, thyramaps));
31}
32
33template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
37
38template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
43
44template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
49
50template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
51void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
52 ExtractVector(const Vector& full, size_t block, Vector& partial) const {
53 XPETRA_TEST_FOR_EXCEPTION(block >= map_->getNumMaps(), std::out_of_range,
54 "ExtractVector: Error, block = " << block << " is too big. The MapExtractor only contains " << map_->getNumMaps() << " partial blocks.");
55 XPETRA_TEST_FOR_EXCEPTION(map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError,
56 "ExtractVector: map_->getMap(" << block << ",false) is null");
57
58 partial.doImport(full, *(map_->getImporter(block)), Xpetra::INSERT);
59}
60
61template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
62void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
63 ExtractVector(const MultiVector& full, size_t block, MultiVector& partial) const {
64 XPETRA_TEST_FOR_EXCEPTION(block >= map_->getNumMaps(),
65 std::out_of_range,
66 "ExtractVector: Error, block = " << block << " is too big. The MapExtractor only contains " << map_->getNumMaps()
67 << " partial blocks.");
68 XPETRA_TEST_FOR_EXCEPTION(
69 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "ExtractVector: map_->getMap(" << block << ",false) is null");
70
71 partial.doImport(full, *(map_->getImporter(block)), Xpetra::INSERT);
72}
73
74template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
75void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
76 ExtractVector(RCP<const Vector>& full, size_t block, RCP<Vector>& partial) const {
77 ExtractVector(*full, block, *partial);
78}
79
80template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
81void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
82 ExtractVector(RCP<Vector>& full, size_t block, RCP<Vector>& partial) const {
83 ExtractVector(*full, block, *partial);
84}
85
86template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
87void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
88 ExtractVector(RCP<const MultiVector>& full, size_t block, RCP<MultiVector>& partial) const {
89 ExtractVector(*full, block, *partial);
90}
91
92template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
93void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
94 ExtractVector(RCP<MultiVector>& full, size_t block, RCP<MultiVector>& partial) const {
95 ExtractVector(*full, block, *partial);
96}
97
98template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
99RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
100MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
101 ExtractVector(RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& full, size_t block, bool bThyraMode) const {
102 XPETRA_TEST_FOR_EXCEPTION(block >= map_->getNumMaps(),
103 std::out_of_range,
104 "ExtractVector: Error, block = " << block << " is too big. The MapExtractor only contains " << map_->getNumMaps()
105 << " partial blocks.");
106 XPETRA_TEST_FOR_EXCEPTION(
107 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "ExtractVector: map_->getMap(" << block << ",false) is null");
108 // first extract partial vector from full vector (using xpetra style GIDs)
109 const RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> vv = Xpetra::VectorFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Build(getMap(block, false), false);
110 ExtractVector(*full, block, *vv);
111 if (bThyraMode == false)
112 return vv;
113 TEUCHOS_TEST_FOR_EXCEPTION(map_->getThyraMode() == false && bThyraMode == true,
114 Xpetra::Exceptions::RuntimeError,
115 "MapExtractor::ExtractVector: ExtractVector in Thyra-style numbering only possible if MapExtractor has been "
116 "created using Thyra-style numbered submaps.");
117 vv->replaceMap(getMap(block, true)); // switch to Thyra-style map
118 return vv;
119}
120
121template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
122RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
123MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
124 ExtractVector(RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& full, size_t block, bool bThyraMode) const {
125 XPETRA_TEST_FOR_EXCEPTION(block >= map_->getNumMaps(),
126 std::out_of_range,
127 "ExtractVector: Error, block = " << block << " is too big. The MapExtractor only contains " << map_->getNumMaps()
128 << " partial blocks.");
129 XPETRA_TEST_FOR_EXCEPTION(
130 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "ExtractVector: map_->getmap(" << block << ",false) is null");
131 // first extract partial vector from full vector (using xpetra style GIDs)
132 const RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> vv = Xpetra::VectorFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Build(getMap(block, false), false);
133
134 ExtractVector(*full, block, *vv);
135 if (bThyraMode == false)
136 return vv;
137 TEUCHOS_TEST_FOR_EXCEPTION(map_->getThyraMode() == false && bThyraMode == true,
138 Xpetra::Exceptions::RuntimeError,
139 "MapExtractor::ExtractVector: ExtractVector in Thyra-style numbering only possible if MapExtractor has been "
140 "created using Thyra-style numbered submaps.");
141 vv->replaceMap(getMap(block, true)); // switch to Thyra-style map
142 return vv;
143}
144
145template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
146RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
147MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
148 ExtractVector(RCP<const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& full, size_t block, bool bThyraMode) const {
149 XPETRA_TEST_FOR_EXCEPTION(block >= map_->getNumMaps(),
150 std::out_of_range,
151 "ExtractVector: Error, block = " << block << " is too big. The MapExtractor only contains " << map_->getNumMaps()
152 << " partial blocks.");
153 XPETRA_TEST_FOR_EXCEPTION(
154 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "ExtractVector: map_->getmap(" << block << ",false) is null");
155 RCP<const BlockedMultiVector> bfull = Teuchos::rcp_dynamic_cast<const BlockedMultiVector>(full);
156 if (bfull.is_null() == true) {
157 // standard case: full is not of type BlockedMultiVector
158 // first extract partial vector from full vector (using xpetra style GIDs)
159 const RCP<MultiVector> vv = MultiVectorFactory::Build(getMap(block, false), full->getNumVectors(), false);
160 // if(bThyraMode == false) {
161 // ExtractVector(*full, block, *vv);
162 // return vv;
163 //} else {
164 RCP<const Map> oldThyMapFull = full->getMap(); // temporarely store map of full
165 RCP<MultiVector> rcpNonConstFull = Teuchos::rcp_const_cast<MultiVector>(full);
166 rcpNonConstFull->replaceMap(map_->getImporter(block)->getSourceMap());
167 ExtractVector(*rcpNonConstFull, block, *vv);
168 TEUCHOS_TEST_FOR_EXCEPTION(map_->getThyraMode() == false && bThyraMode == true,
169 Xpetra::Exceptions::RuntimeError,
170 "MapExtractor::ExtractVector: ExtractVector in Thyra-style numbering only possible if MapExtractor has been "
171 "created using Thyra-style numbered submaps.");
172 if (bThyraMode == true)
173 vv->replaceMap(getMap(block, true)); // switch to Thyra-style map
174 rcpNonConstFull->replaceMap(oldThyMapFull);
175 return vv;
176 //}
177 } else {
178 // special case: full is of type BlockedMultiVector
179 XPETRA_TEST_FOR_EXCEPTION(map_->getNumMaps() != bfull->getBlockedMap()->getNumMaps(),
180 Xpetra::Exceptions::RuntimeError,
181 "ExtractVector: Number of blocks in map extractor is " << map_->getNumMaps() << " but should be "
182 << bfull->getBlockedMap()->getNumMaps()
183 << " (number of blocks in BlockedMultiVector)");
184 return bfull->getMultiVector(block, bThyraMode);
185 }
186}
187
188template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
189RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
190MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
191 ExtractVector(RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& full, size_t block, bool bThyraMode) const {
192 XPETRA_TEST_FOR_EXCEPTION(block >= map_->getNumMaps(),
193 std::out_of_range,
194 "ExtractVector: Error, block = " << block << " is too big. The MapExtractor only contains " << map_->getNumMaps()
195 << " partial blocks.");
196 XPETRA_TEST_FOR_EXCEPTION(
197 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "ExtractVector: map_->getmap(" << block << ",false) is null");
198 RCP<BlockedMultiVector> bfull = Teuchos::rcp_dynamic_cast<BlockedMultiVector>(full);
199 if (bfull.is_null() == true) {
200 // standard case: full is not of type BlockedMultiVector
201 // first extract partial vector from full vector (using xpetra style GIDs)
202 const RCP<MultiVector> vv = MultiVectorFactory::Build(getMap(block, false), full->getNumVectors(), false);
203 // if(bThyraMode == false) {
204 // ExtractVector(*full, block, *vv);
205 // return vv;
206 //} else {
207 RCP<const Map> oldThyMapFull = full->getMap(); // temporarely store map of full
208 full->replaceMap(map_->getImporter(block)->getSourceMap());
209 ExtractVector(*full, block, *vv);
210 TEUCHOS_TEST_FOR_EXCEPTION(map_->getThyraMode() == false && bThyraMode == true,
211 Xpetra::Exceptions::RuntimeError,
212 "MapExtractor::ExtractVector: ExtractVector in Thyra-style numbering only possible if MapExtractor has been "
213 "created using Thyra-style numbered submaps.");
214 if (bThyraMode == true)
215 vv->replaceMap(getMap(block, true)); // switch to Thyra-style map
216 full->replaceMap(oldThyMapFull);
217 return vv;
218 //}
219 } else {
220 // special case: full is of type BlockedMultiVector
221 XPETRA_TEST_FOR_EXCEPTION(map_->getNumMaps() != bfull->getBlockedMap()->getNumMaps(),
222 Xpetra::Exceptions::RuntimeError,
223 "ExtractVector: Number of blocks in map extractor is " << map_->getNumMaps() << " but should be "
224 << bfull->getBlockedMap()->getNumMaps()
225 << " (number of blocks in BlockedMultiVector)");
226 return bfull->getMultiVector(block, bThyraMode);
227 }
228}
229
230template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
231RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
232MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
233 ExtractVector(RCP<const Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& full, size_t block, bool bThyraMode) const {
234 XPETRA_TEST_FOR_EXCEPTION(block >= map_->getNumMaps(),
235 std::out_of_range,
236 "ExtractVector: Error, block = " << block << " is too big. The MapExtractor only contains " << map_->getNumMaps()
237 << " partial blocks.");
238 XPETRA_TEST_FOR_EXCEPTION(
239 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "ExtractVector: map_->getmap(" << block << ",false) is null");
240 XPETRA_TEST_FOR_EXCEPTION(map_->getNumMaps() != full->getBlockedMap()->getNumMaps(),
241 Xpetra::Exceptions::RuntimeError,
242 "ExtractVector: Number of blocks in map extractor is " << map_->getNumMaps() << " but should be "
243 << full->getBlockedMap()->getNumMaps()
244 << " (number of blocks in BlockedMultiVector)");
245 Teuchos::RCP<MultiVector> vv = full->getMultiVector(block, bThyraMode);
246 return vv;
247}
248
249template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
250RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
251MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
252 ExtractVector(RCP<Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& full, size_t block, bool bThyraMode) const {
253 XPETRA_TEST_FOR_EXCEPTION(block >= map_->getNumMaps(),
254 std::out_of_range,
255 "ExtractVector: Error, block = " << block << " is too big. The MapExtractor only contains " << map_->getNumMaps()
256 << " partial blocks.");
257 XPETRA_TEST_FOR_EXCEPTION(
258 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "ExtractVector: map_->getmap(" << block << ",false) is null");
259 XPETRA_TEST_FOR_EXCEPTION(map_->getNumMaps() != full->getBlockedMap()->getNumMaps(),
260 Xpetra::Exceptions::RuntimeError,
261 "ExtractVector: Number of blocks in map extractor is " << map_->getNumMaps() << " but should be "
262 << full->getBlockedMap()->getNumMaps()
263 << " (number of blocks in BlockedMultiVector)");
264 Teuchos::RCP<MultiVector> vv = full->getMultiVector(block, bThyraMode);
265 return vv;
266}
267
268template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
269void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
270 InsertVector(const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& partial, size_t block, Vector& full, bool bThyraMode) const {
271 XPETRA_TEST_FOR_EXCEPTION(block >= map_->getNumMaps(),
272 std::out_of_range,
273 "ExtractVector: Error, block = " << block << " is too big. The MapExtractor only contains " << map_->getNumMaps()
274 << " partial blocks.");
275 XPETRA_TEST_FOR_EXCEPTION(
276 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "ExtractVector: map_->getmap(" << block << ",false) is null");
277 XPETRA_TEST_FOR_EXCEPTION(map_->getThyraMode() == false && bThyraMode == true,
278 Xpetra::Exceptions::RuntimeError,
279 "MapExtractor::InsertVector: InsertVector in Thyra-style numbering only possible if MapExtractor has been created "
280 "using Thyra-style numbered submaps.");
281 if (bThyraMode) {
282 // NOTE: the importer objects in the BlockedMap are always using Xpetra GIDs (or Thyra style Xpetra GIDs)
283 // The source map corresponds to the full map (in Xpetra GIDs) starting with GIDs from zero. The GIDs are consecutive in Thyra mode
284 // The target map is the partial map (in the corresponding Xpetra GIDs)
285
286 // TODO can we skip the Export call in special cases (i.e. Src = Target map, same length, etc...)
287
288 // store original GIDs (could be Thyra GIDs)
289 RCP<const MultiVector> rcpPartial = Teuchos::rcpFromRef(partial);
290 RCP<MultiVector> rcpNonConstPartial = Teuchos::rcp_const_cast<MultiVector>(rcpPartial);
291 RCP<const Map> oldThyMapPartial = rcpNonConstPartial->getMap(); // temporarely store map of partial
292 RCP<const Map> oldThyMapFull = full.getMap(); // temporarely store map of full
293
294 // check whether getMap(block,false) is identical to target map of importer
295 XPETRA_TEST_FOR_EXCEPTION(map_->getMap(block, false)->isSameAs(*(map_->getImporter(block)->getTargetMap())) == false,
296 Xpetra::Exceptions::RuntimeError,
297 "MapExtractor::InsertVector: InsertVector in Thyra-style mode: Xpetra GIDs of partial vector are not identical "
298 "to target Map of Importer. This should not be.");
299
300 // XPETRA_TEST_FOR_EXCEPTION(full.getMap()->isSameAs(*(map_->getImporter(block)->getSourceMap()))==false,
301 // Xpetra::Exceptions::RuntimeError,
302 // "MapExtractor::InsertVector: InsertVector in Thyra-style mode: Xpetra GIDs of full vector are not identical to source Map of
303 // Importer. This should not be.");
304
305 rcpNonConstPartial->replaceMap(getMap(block, false)); // temporarely switch to xpetra-style map
306 full.replaceMap(map_->getImporter(block)->getSourceMap()); // temporarely switch to Xpetra GIDs
307
308 // do the Export
309 full.doExport(*rcpNonConstPartial, *(map_->getImporter(block)), Xpetra::INSERT);
310
311 // switch back to original maps
312 full.replaceMap(oldThyMapFull); // reset original map (Thyra GIDs)
313 rcpNonConstPartial->replaceMap(oldThyMapPartial); // change map back to original map
314 } else {
315 // Xpetra style numbering
316 full.doExport(partial, *(map_->getImporter(block)), Xpetra::INSERT);
317 }
318}
319
320template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
321void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
322 InsertVector(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& partial, size_t block, MultiVector& full, bool bThyraMode) const {
323 XPETRA_TEST_FOR_EXCEPTION(block >= map_->getNumMaps(),
324 std::out_of_range,
325 "ExtractVector: Error, block = " << block << " is too big. The MapExtractor only contains " << map_->getNumMaps()
326 << " partial blocks.");
327 XPETRA_TEST_FOR_EXCEPTION(
328 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "ExtractVector: map_->getmap(" << block << ",false) is null");
329 XPETRA_TEST_FOR_EXCEPTION(map_->getThyraMode() == false && bThyraMode == true,
330 Xpetra::Exceptions::RuntimeError,
331 "MapExtractor::InsertVector: InsertVector in Thyra-style numbering only possible if MapExtractor has been created "
332 "using Thyra-style numbered submaps.");
333 if (bThyraMode) {
334 // NOTE: the importer objects in the BlockedMap are always using Xpetra GIDs (or Thyra style Xpetra GIDs)
335 // The source map corresponds to the full map (in Xpetra GIDs) starting with GIDs from zero. The GIDs are consecutive in Thyra mode
336 // The target map is the partial map (in the corresponding Xpetra GIDs)
337
338 // TODO can we skip the Export call in special cases (i.e. Src = Target map, same length, etc...)
339
340 // store original GIDs (could be Thyra GIDs)
341 RCP<const MultiVector> rcpPartial = Teuchos::rcpFromRef(partial);
342 RCP<MultiVector> rcpNonConstPartial = Teuchos::rcp_const_cast<MultiVector>(rcpPartial);
343 RCP<const Map> oldThyMapPartial = rcpNonConstPartial->getMap(); // temporarely store map of partial
344 RCP<const Map> oldThyMapFull = full.getMap(); // temporarely store map of full
345
346 // check whether getMap(block,false) is identical to target map of importer
347 XPETRA_TEST_FOR_EXCEPTION(map_->getMap(block, false)->isSameAs(*(map_->getImporter(block)->getTargetMap())) == false,
348 Xpetra::Exceptions::RuntimeError,
349 "MapExtractor::InsertVector: InsertVector in Thyra-style mode: Xpetra GIDs of partial vector are not identical "
350 "to target Map of Importer. This should not be.");
351
352 // XPETRA_TEST_FOR_EXCEPTION(full.getMap()->isSameAs(*(map_->getImporter(block)->getSourceMap()))==false,
353 // Xpetra::Exceptions::RuntimeError,
354 // "MapExtractor::InsertVector: InsertVector in Thyra-style mode: Xpetra GIDs of full vector are not identical to source Map of
355 // Importer. This should not be.");
356
357 rcpNonConstPartial->replaceMap(getMap(block, false)); // temporarely switch to xpetra-style map
358 full.replaceMap(map_->getImporter(block)->getSourceMap()); // temporarely switch to Xpetra GIDs
359
360 // do the Export
361 full.doExport(*rcpNonConstPartial, *(map_->getImporter(block)), Xpetra::INSERT);
362
363 // switch back to original maps
364 full.replaceMap(oldThyMapFull); // reset original map (Thyra GIDs)
365 rcpNonConstPartial->replaceMap(oldThyMapPartial); // change map back to original map
366 } else {
367 // Xpetra style numbering
368 full.doExport(partial, *(map_->getImporter(block)), Xpetra::INSERT);
369 }
370}
371
372template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
373void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
374 InsertVector(RCP<const Vector> partial, size_t block, RCP<Vector> full, bool bThyraMode) const {
375 InsertVector(*partial, block, *full, bThyraMode);
376}
377
378template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
379void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
380 InsertVector(RCP<Vector> partial, size_t block, RCP<Vector> full, bool bThyraMode) const {
381 InsertVector(*partial, block, *full, bThyraMode);
382}
383
384template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
385void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
386 InsertVector(RCP<const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> partial,
387 size_t block,
388 RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> full,
389 bool bThyraMode) const {
390 RCP<BlockedMultiVector> bfull = Teuchos::rcp_dynamic_cast<BlockedMultiVector>(full);
391 if (bfull.is_null() == true)
392 InsertVector(*partial, block, *full, bThyraMode);
393 else {
394 XPETRA_TEST_FOR_EXCEPTION(
395 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "InsertVector: map_->getmap(" << block << ",false) is null");
396
397#if 0
398 // WCMCLEN - ETI: MultiVector::setMultiVector() doesn't exist.
399 // WCMCLEN - ETI: but BlockedMultiVector::setMultiVector() does... should this be using bfull.
400 full->setMultiVector(block, partial, bThyraMode);
401#else
402 throw std::runtime_error("Xpetra::MultiVector::setMultiVector() doesn't exist in " + std::string(__FILE__) + ":" + std::to_string(__LINE__));
403#endif
404 }
405}
406
407template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
408void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
409 InsertVector(RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> partial,
410 size_t block,
411 RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> full,
412 bool bThyraMode) const {
413 RCP<BlockedMultiVector> bfull = Teuchos::rcp_dynamic_cast<BlockedMultiVector>(full);
414 if (bfull.is_null() == true)
415 InsertVector(*partial, block, *full, bThyraMode);
416 else {
417 XPETRA_TEST_FOR_EXCEPTION(
418 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "InsertVector: map_->getmap(" << block << ",false) is null");
419
420 bfull->setMultiVector(block, partial, bThyraMode);
421 }
422}
423
424template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
425void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
426 InsertVector(RCP<const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> partial,
427 size_t block,
428 RCP<Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> full,
429 bool bThyraMode) const {
430 XPETRA_TEST_FOR_EXCEPTION(
431 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "InsertVector: map_->getmap(" << block << ",false) is null");
432
433 full->setMultiVector(block, partial, bThyraMode);
434}
435
436template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
437void MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
438 InsertVector(RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> partial,
439 size_t block,
440 RCP<Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> full,
441 bool bThyraMode) const {
442 XPETRA_TEST_FOR_EXCEPTION(
443 map_->getMap(block, false) == null, Xpetra::Exceptions::RuntimeError, "InsertVector: map_->getmap(" << block << ",false) is null");
444 full->setMultiVector(block, partial, bThyraMode);
445}
446
447template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
448RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
449MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
450 getVector(size_t i, bool bThyraMode, bool bZero) const {
451 XPETRA_TEST_FOR_EXCEPTION(map_->getThyraMode() == false && bThyraMode == true,
452 Xpetra::Exceptions::RuntimeError,
453 "MapExtractor::getVector: getVector in Thyra-style numbering only possible if MapExtractor has been created using "
454 "Thyra-style numbered submaps.");
455 // TODO check whether this can return a blocked multivector
456 return Xpetra::VectorFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Build(getMap(i, bThyraMode), bZero);
457}
458
459template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
460RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
461MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
462 getVector(size_t i, size_t numvec, bool bThyraMode, bool bZero) const {
463 XPETRA_TEST_FOR_EXCEPTION(map_->getThyraMode() == false && bThyraMode == true,
464 Xpetra::Exceptions::RuntimeError,
465 "MapExtractor::getVector: getVector in Thyra-style numbering only possible if MapExtractor has been created using "
466 "Thyra-style numbered submaps.");
467 // TODO check whether this can return a blocked multivector
468 return MultiVectorFactory::Build(getMap(i, bThyraMode), numvec, bZero);
469}
470
472template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
473bool MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
474 getThyraMode() const {
475 return map_->getThyraMode();
476}
477
478template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
479size_t
480MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
481 NumMaps() const {
482 return map_->getNumMaps();
483}
484
485template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
486const RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>
487MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
488 getMap(size_t i, bool bThyraMode) const {
489 return map_->getMap(i, bThyraMode);
490}
491
492template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
493const RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>
498
499template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
500const RCP<const Xpetra::BlockedMap<LocalOrdinal, GlobalOrdinal, Node>>
505
506template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
507const RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>
508MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
509 getFullMap() const {
510 return map_->getFullMap();
511}
512
513template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
514size_t
515MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
516 getMapIndexForGID(GlobalOrdinal gid) const {
517 return map_->getMapIndexForGID(gid);
518}
519
520} // namespace Xpetra
521
522#endif /* XPETRA_MAPEXTRACTOR_DEF_HPP_ */
XPETRA_TEST_FOR_EXCEPTION
#define XPETRA_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Definition Xpetra_ConfigDefs.hpp:107
Xpetra_MapExtractor_decl.hpp
Teuchos::RCP::is_null
bool is_null() const
Xpetra::DistObject::doExport
virtual void doExport(const DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node > &source, const Export< LocalOrdinal, GlobalOrdinal, Node > &exporter, CombineMode CM)=0
Export data into this object using an Export object ("forward mode").
Xpetra::DistObject::getMap
virtual Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > getMap() const =0
The Map describing the parallel distribution of this object.
Xpetra::DistObject::doImport
virtual void doImport(const DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node > &source, const Import< LocalOrdinal, GlobalOrdinal, Node > &importer, CombineMode CM)=0
Import data into this object using an Import object ("forward mode").
Xpetra::Exceptions::RuntimeError
Exception throws to report errors in the internal logical of the program.
Definition Xpetra_Exceptions.hpp:65
Xpetra::MapExtractor::InsertVector
void InsertVector(const Vector &partial, size_t block, Vector &full, bool bThyraMode=false) const
Definition Xpetra_MapExtractor_def.hpp:270
Xpetra::MapExtractor::getVector
RCP< Vector > getVector(size_t i, bool bThyraMode=false, bool bZero=true) const
Definition Xpetra_MapExtractor_def.hpp:450
Xpetra::MapExtractor::MapExtractor
MapExtractor(const RCP< const Map > &fullmap, const std::vector< RCP< const Map > > &maps, bool bThyraMode=false)
Definition Xpetra_MapExtractor_def.hpp:23
Xpetra::MapExtractor::getThyraMode
bool getThyraMode() const
returns true, if sub maps are stored in Thyra-style numbering
Definition Xpetra_MapExtractor_def.hpp:474
Xpetra::MapExtractor::getBlockedMap
const RCP< const Xpetra::BlockedMap< LocalOrdinal, GlobalOrdinal, Node > > getBlockedMap() const
get the underlying BlockedMap object (as BlockedMap)
Definition Xpetra_MapExtractor_def.hpp:502
Xpetra::MapExtractor::NumMaps
size_t NumMaps() const
number of partial maps
Definition Xpetra_MapExtractor_def.hpp:481
Xpetra::MapExtractor::getFullMap
const RCP< const Map > getFullMap() const
the full map
Definition Xpetra_MapExtractor_def.hpp:509
Xpetra::MapExtractor::ExtractVector
void ExtractVector(const Vector &full, size_t block, Vector &partial) const
Definition Xpetra_MapExtractor_def.hpp:52
Xpetra::MapExtractor::~MapExtractor
virtual ~MapExtractor()
Destructor.
Definition Xpetra_MapExtractor_def.hpp:46
Xpetra::MapExtractor::getMapIndexForGID
size_t getMapIndexForGID(GlobalOrdinal gid) const
returns map index in map extractor which contains GID
Definition Xpetra_MapExtractor_def.hpp:516
Xpetra::MapExtractor::getMap
const RCP< const Map > getMap() const
get the underlying BlockedMap object (as Map)
Definition Xpetra_MapExtractor_def.hpp:495
Xpetra::MultiVectorFactory::Build
static Teuchos::RCP< MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Build(const Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &map, size_t NumVectors, bool zeroOut=true)
Constructor specifying the number of non-zeros for all rows.
Definition Xpetra_MultiVectorFactory_def.hpp:24
Xpetra::MultiVector::replaceMap
virtual void replaceMap(const RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &map)=0
Xpetra::VectorFactory::Build
static Teuchos::RCP< Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Build(const Teuchos::RCP< const Xpetra::Map< LocalOrdinal, GlobalOrdinal, Node > > &map, bool zeroOut=true)
Constructor specifying the number of non-zeros for all rows.
Definition Xpetra_VectorFactory_decl.hpp:45
TEUCHOS_TEST_FOR_EXCEPTION
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)