Debian Codegraph @

packages/tpetra/core/test/FEMultiVector/FEMultiVector_UnitTests.cpp

raw
1 // @HEADER
2 // *****************************************************************************
3 // Tpetra: Templated Linear Algebra Services Package
4 //
5 // Copyright 2008 NTESS and the Tpetra contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9
10 #include "Tpetra_TestingUtilities.hpp"
11 #include "Tpetra_CrsGraph.hpp"
12 #include "Tpetra_CrsMatrix.hpp"
13 #include "Tpetra_Core.hpp"
14 #include "Tpetra_Distributor.hpp"
15 #include "Tpetra_Map.hpp"
16 #include "Tpetra_Util.hpp"
17 #include "Tpetra_Import.hpp"
18 #include "Tpetra_FEMultiVector.hpp"
19 #include "Tpetra_Assembly_Helpers.hpp"
20 #include "Tpetra_Details_gathervPrint.hpp"
21 #include "Teuchos_OrdinalTraits.hpp"
22 #include "Teuchos_ScalarTraits.hpp"
23 #include "Teuchos_VerboseObject.hpp"
24 #include <map>
25
26 namespace {
27
28 template<class T1, class T2>
29 void vector_check(size_t N, T1 & v1, T2 & v2) {
30 const int myRank = v1.getMap()->getComm()->getRank();
31 for(size_t i=0; i<N; i++)
32 if(v1.getDataNonConst(0)[i] != v2.getDataNonConst(0)[i]) {
33 std::stringstream oss;
34 oss<<"["<<myRank<<"] Error: Mismatch on unknown "<<i<<" "<<v1.getDataNonConst(0)[i]<<" != "<<v2.getDataNonConst(0)[i]<<std::endl;
35 throw std::runtime_error(oss.str());
36 }
37 }
38
39 using std::endl;
40
41 using Teuchos::RCP;
42 using Teuchos::rcp;
43 using Teuchos::Array;
44 using Teuchos::Comm;
45 using Teuchos::OrdinalTraits;
46 using Teuchos::ScalarTraits;
47 using Teuchos::VERB_DEFAULT;
48 using Teuchos::VERB_NONE;
49 using Teuchos::VERB_LOW;
50 using Teuchos::VERB_MEDIUM;
51 using Teuchos::VERB_HIGH;
52 using Teuchos::VERB_EXTREME;
53
54 using Tpetra::createContigMapWithNode;
55 using GST = Tpetra::global_size_t;
56
57 //
58 // UNIT TESTS
59 //
60
61 TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL( FEMultiVector, doImport, LO, GO, Scalar, NO )
62 {
63 const GST INVALID = Teuchos::OrdinalTraits<GST>::invalid ();
64 const RCP<const Comm<int> > comm = Tpetra::getDefaultComm();
65 const int myRank = comm->getRank();
66 const int numProcs = comm->getSize();
67 if(numProcs==1) return;
68
69 // Prepare for verbose output, if applicable.
70 // Teuchos::EVerbosityLevel verbLevel = verbose ? VERB_EXTREME : VERB_NONE;
71 Teuchos::EVerbosityLevel verbLevel = VERB_EXTREME;
72 const bool doPrint = includesVerbLevel (verbLevel, VERB_EXTREME, true);
73 if (doPrint) {
74 out << "FEMultiVector unit test" << std::endl;
75 }
76 Teuchos::OSTab tab1 (out); // Add one tab level
77
78 std::ostringstream err;
79 int lclErr = 0;
80
81 try {
82 Teuchos::OSTab tab2 (out);
83 const int num_local_elements = 3;
84
85 // create Map
86 RCP<const Tpetra::Map<LO, GO, NO> > map =
87 rcp( new Tpetra::Map<LO,GO,NO>(INVALID, num_local_elements, 0, comm));
88
89 // create CrsGraph object
90 RCP<Tpetra::CrsGraph<LO, GO, NO> > graph =
91 rcp (new Tpetra::CrsGraph<LO, GO, NO> (map, 3));
92
93 // Create a simple tridiagonal source graph.
94 Array<GO> entry(1);
95 for (size_t i = 0; i < map->getLocalNumElements (); i++) {
96 const GO globalrow = map->getGlobalElement (i);
97 entry[0] = globalrow;
98 graph->insertGlobalIndices (globalrow, entry());
99 if (myRank!=0) {
100 entry[0] = globalrow-1;
101 graph->insertGlobalIndices (globalrow, entry());
102 }
103 if (myRank!=numProcs-1) {
104 entry[0] = globalrow+1;
105 graph->insertGlobalIndices (globalrow, entry());
106 }
107 }
108 graph->fillComplete();
109
110
111 Scalar ZERO = Teuchos::ScalarTraits<Scalar>::zero();
112 Scalar ONE = Teuchos::ScalarTraits<Scalar>::one();
113 RCP<const Tpetra::Map<LO,GO,NO> > domainMap = graph->getDomainMap();
114 RCP<const Tpetra::Map<LO,GO,NO> > columnMap = graph->getColMap();
115 RCP<const Tpetra::Import<LO,GO,NO> > importer = graph->getImporter();
116 Tpetra::MultiVector<Scalar,LO,GO,NO> Vdomain(domainMap,1), Vcolumn(columnMap,1);
117 Tpetra::FEMultiVector<Scalar,LO,GO,NO> Vfe(domainMap,importer,1);
118 size_t Ndomain = domainMap->getLocalNumElements();
119 size_t Ncolumn = domainMap->getLocalNumElements();
120
121 if(importer.is_null()) throw std::runtime_error("No valid importer");
122
123 // 1) Test column -> domain (no off-proc addition)
124 Vcolumn.putScalar(ZERO);
125 for(size_t i=0; i<Ndomain; i++)
126 Vcolumn.getDataNonConst(0)[i] = domainMap->getGlobalElement(i);
127 Vdomain.doExport(Vcolumn,*importer,Tpetra::ADD);
128
129
130 Vfe.beginAssembly();
131 Vfe.putScalar(ZERO);
132 for(size_t i=0; i<Ndomain; i++)
133 Vfe.getDataNonConst(0)[i] = domainMap->getGlobalElement(i);
134 Vfe.endAssembly();
135 vector_check(Ndomain,Vfe,Vdomain);
136
137 // 2) Test column -> domain (with off-proc addition)
138 Vdomain.putScalar(ZERO);
139 Vcolumn.putScalar(ONE);
140 Vdomain.doExport(Vcolumn,*importer,Tpetra::ADD);
141
142 Vfe.putScalar(ZERO);
143 Vfe.beginAssembly();
144 Vfe.putScalar(ONE);
145 Vfe.endAssembly();
146 vector_check(Ncolumn,Vfe,Vdomain);
147 } catch (std::exception& e) {
148 err << "Proc " << myRank << ": " << e.what () << std::endl;
149 lclErr = 1;
150 }
151
152
153 int gblErr = 0;
154 Teuchos::reduceAll<int, int> (*comm, Teuchos::REDUCE_MAX, lclErr, Teuchos::outArg (gblErr));
155 TEST_EQUALITY_CONST( gblErr, 0 );
156 if (gblErr != 0) {
157 Tpetra::Details::gathervPrint (out, err.str (), *comm);
158 out << "Above test failed; aborting further tests" << std::endl;
159 return;
160 }
161 }
162
163 TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL( FEMultiVector, AssemblyHelpers, LO , GO , Scalar , Node )
164 {
165 const GST INVALID = Teuchos::OrdinalTraits<GST>::invalid ();
166 const RCP<const Comm<int> > comm = Tpetra::getDefaultComm();
167 int rank = comm->getRank();
168 int size = comm->getSize();
169
170 // create maps
171 const size_t numLocal = 10;
172 const size_t numOverlap = numLocal + (rank!=0) + (rank!=size-1);
173 RCP<const Tpetra::Map<LO,GO,Node> > map = createContigMapWithNode<LO,GO,Node>(INVALID,numLocal,comm);
174
175 Array<GO> overlapList(numOverlap);
176 for(size_t i = 0; i< numLocal; i++) {
177 overlapList[i] = map->getGlobalElement(i);
178 }
179 size_t iii = numLocal;
180 if(rank!=0) {overlapList[iii] = overlapList[0]-1; iii++;}
181 if(rank!=size-1) {overlapList[iii] = overlapList[numLocal-1]+1;}
182
183 RCP<const Tpetra::Map<LO,GO,Node> > overlapMap = rcp(new Tpetra::Map<LO,GO,Node>(INVALID,overlapList(),0,comm));
184 RCP<const Tpetra::Import<LO,GO,Node> > importer = rcp(new Tpetra::Import<LO,GO,Node>(map,overlapMap));
185
186 Tpetra::FEMultiVector<Scalar,LO,GO,Node> v1(map,importer,1);
187 Tpetra::FEMultiVector<Scalar,LO,GO,Node> v2(map,importer,1);
188 Tpetra::FEMultiVector<Scalar,LO,GO,Node> v3(map,importer,1);
189
190 // Just check to make sure beginAssembly() / endAssembly() compile
191 Tpetra::beginAssembly(v1,v2,v3);
192
193 Tpetra::endAssembly(v1,v2,v3);
194 }
195
196 #define UNIT_TEST_GROUP( SC, LO, GO, NO ) \
197 TEUCHOS_UNIT_TEST_TEMPLATE_4_INSTANT( FEMultiVector, doImport, LO, GO, SC, NO ) \
198 TEUCHOS_UNIT_TEST_TEMPLATE_4_INSTANT( FEMultiVector, AssemblyHelpers, LO, GO, SC, NO )
199
200 TPETRA_ETI_MANGLING_TYPEDEFS()
201
202 TPETRA_INSTANTIATE_TESTMV( UNIT_TEST_GROUP )
203 }