1 #include "TestUtil.hpp"
2 #include "moab/Core.hpp"
3 #include "moab/ReadUtilIface.hpp"
4 #include "TagInfo.hpp"
5 #include "MBTagConventions.hpp"
6
7 using namespace moab;
8
9 std::string example = TestDir + "/io/homme3x3458.t.3.nc";
10 std::string conn_fname = TestDir + "/io/HommeMapping.nc";
11
12 #ifdef MOAB_HAVE_MPI
13 #include "moab_mpi.h"
14 #include "moab/ParallelComm.hpp"
15 #endif
16
17 void test_read_all();
18 void test_read_onevar();
19 void test_read_onetimestep();
20 void test_read_nomesh();
21 void test_read_novars();
22 void test_read_coord_vars(); // Test reading coordinate variables
23 void test_gather_onevar(); // Test gather set with one variable
24 void test_read_conn(); // Test reading connectivity file only
25
26 void get_options(std::string& opts);
27
28 const int levels = 3;
29
main(int argc,char * argv[])30 int main(int argc, char* argv[])
31 {
32 int result = 0;
33
34 #ifdef MOAB_HAVE_MPI
35 int fail = MPI_Init(&argc, &argv);
36 if (fail)
37 return 1;
38 #else
39 argv[0] = argv[argc - argc]; // To remove the warnings in serial mode about unused variables
40 #endif
41
42 result += RUN_TEST(test_read_all);
43 result += RUN_TEST(test_read_onevar);
44 result += RUN_TEST(test_read_onetimestep);
45 result += RUN_TEST(test_read_nomesh);
46 result += RUN_TEST(test_read_novars);
47 result += RUN_TEST(test_read_coord_vars);
48 result += RUN_TEST(test_gather_onevar);
49 result += RUN_TEST(test_read_conn);
50
51 #ifdef MOAB_HAVE_MPI
52 fail = MPI_Finalize();
53 if (fail)
54 return 1;
55 #endif
56
57 return result;
58 }
59
test_read_all()60 void test_read_all()
61 {
62 Core moab;
63 Interface& mb = moab;
64
65 std::string opts;
66 get_options(opts);
67
68 ErrorCode rval = mb.load_file(example.c_str(), NULL, opts.c_str());
69 CHECK_ERR(rval);
70
71 // Check for proper tags
72 Tag Ttag0, Ttag1;
73 rval = mb.tag_get_handle("T0", levels, MB_TYPE_DOUBLE, Ttag0);
74 CHECK_ERR(rval);
75
76 rval = mb.tag_get_handle("T1", levels, MB_TYPE_DOUBLE, Ttag1);
77 CHECK_ERR(rval);
78 }
79
test_read_onevar()80 void test_read_onevar()
81 {
82 Core moab;
83 Interface& mb = moab;
84
85 std::string opts;
86 get_options(opts);
87
88 // Read mesh and read vertex variable T at all timesteps
89 opts += std::string(";VARIABLE=T");
90 ErrorCode rval = mb.load_file(example.c_str(), NULL, opts.c_str());
91 CHECK_ERR(rval);
92
93 #ifdef MOAB_HAVE_MPI
94 ParallelComm* pcomm = ParallelComm::get_pcomm(&mb, 0);
95 int procs = pcomm->proc_config().proc_size();
96 #else
97 int procs = 1;
98 #endif
99
100 // Make check runs this test on one processor
101 if (1 == procs) {
102 // Check for proper tags
103 Tag Ttag0, Ttag1;
104 rval = mb.tag_get_handle("T0", levels, MB_TYPE_DOUBLE, Ttag0);
105 CHECK_ERR(rval);
106 rval = mb.tag_get_handle("T1", levels, MB_TYPE_DOUBLE, Ttag1);
107 CHECK_ERR(rval);
108
109 // Get vertices
110 Range verts;
111 rval = mb.get_entities_by_type(0, MBVERTEX, verts);
112 CHECK_ERR(rval);
113 CHECK_EQUAL((size_t)3458, verts.size());
114
115 // Get all values of tag T0
116 int count;
117 void* Tbuf;
118 rval = mb.tag_iterate(Ttag0, verts.begin(), verts.end(), count, Tbuf);
119 CHECK_ERR(rval);
120 CHECK_EQUAL((size_t)count, verts.size());
121
122 const double eps = 0.0001;
123 double* data = (double*) Tbuf;
124
125 // Check first level values on 4 strategically selected vertices
126 CHECK_REAL_EQUAL(233.1136, data[0 * levels], eps); // First vert
127 CHECK_REAL_EQUAL(236.1505, data[1728 * levels], eps); // Median vert
128 CHECK_REAL_EQUAL(235.7722, data[1729 * levels], eps); // Median vert
129 CHECK_REAL_EQUAL(234.0416, data[3457 * levels], eps); // Last vert
130 }
131 }
132
test_read_onetimestep()133 void test_read_onetimestep()
134 {
135 Core moab;
136 Interface& mb = moab;
137
138 std::string opts;
139 get_options(opts);
140
141 opts += std::string(";TIMESTEP=1");
142 ErrorCode rval = mb.load_file(example.c_str(), NULL, opts.c_str());
143 CHECK_ERR(rval);
144
145 // Check for proper tags
146 Tag Ttag0, Ttag1;
147 rval = mb.tag_get_handle("T0", levels, MB_TYPE_DOUBLE, Ttag0);
148 CHECK_EQUAL(rval, MB_TAG_NOT_FOUND);
149
150 rval = mb.tag_get_handle("T1", levels, MB_TYPE_DOUBLE, Ttag1);
151 CHECK_ERR(rval);
152 }
153
test_read_nomesh()154 void test_read_nomesh()
155 {
156 Core moab;
157 Interface& mb = moab;
158
159 // Need a set for nomesh to work right
160 EntityHandle file_set;
161 ErrorCode rval = mb.create_meshset(MESHSET_SET, file_set);
162 CHECK_ERR(rval);
163
164 std::string orig, opts;
165 get_options(orig);
166
167 opts = orig + std::string(";TIMESTEP=0");
168 rval = mb.load_file(example.c_str(), &file_set, opts.c_str());
169 CHECK_ERR(rval);
170
171 // Check for proper tag
172 Tag Ttag0, Ttag1;
173 rval = mb.tag_get_handle("T0", levels, MB_TYPE_DOUBLE, Ttag0);
174 CHECK_ERR(rval);
175
176 rval = mb.tag_get_handle("T1", levels, MB_TYPE_DOUBLE, Ttag1);
177 CHECK_EQUAL(rval, MB_TAG_NOT_FOUND);
178
179 // Now read 2nd timestep with nomesh option
180 opts = orig + std::string(";TIMESTEP=1;NOMESH");
181 rval = mb.load_file(example.c_str(), &file_set, opts.c_str());
182 CHECK_ERR(rval);
183
184 // Check for proper tag
185 rval = mb.tag_get_handle("T1", levels, MB_TYPE_DOUBLE, Ttag1);
186 CHECK_ERR(rval);
187 }
188
test_read_novars()189 void test_read_novars()
190 {
191 Core moab;
192 Interface& mb = moab;
193
194 // Need a set for nomesh to work right
195 EntityHandle set;
196 ErrorCode rval = mb.create_meshset(MESHSET_SET, set);
197 CHECK_ERR(rval);
198
199 std::string orig, opts;
200 get_options(orig);
201
202 opts = orig + std::string(";NOMESH;VARIABLE=");
203 rval = mb.load_file(example.c_str(), &set, opts.c_str());
204 CHECK_ERR(rval);
205
206 opts = orig + std::string(";VARIABLE=;TIMESTEP=0");
207 rval = mb.load_file(example.c_str(), &set, opts.c_str());
208 CHECK_ERR(rval);
209
210 // Check for proper tag
211 Tag Ttag0, Ttag1;
212 rval = mb.tag_get_handle("T0", levels, MB_TYPE_DOUBLE, Ttag0);
213 CHECK_EQUAL(rval, MB_TAG_NOT_FOUND);
214
215 opts = orig + std::string(";VARIABLE=T;TIMESTEP=0;NOMESH");
216 rval = mb.load_file(example.c_str(), &set, opts.c_str());
217 CHECK_ERR(rval);
218
219 rval = mb.tag_get_handle("T0", levels, MB_TYPE_DOUBLE, Ttag0);
220 CHECK_ERR(rval);
221
222 rval = mb.tag_get_handle("T1", levels, MB_TYPE_DOUBLE, Ttag1);
223 CHECK_EQUAL(rval, MB_TAG_NOT_FOUND);
224
225 // Now read 2nd timestep with nomesh option
226 opts = orig + std::string(";TIMESTEP=1;NOMESH");
227 rval = mb.load_file(example.c_str(), &set, opts.c_str());
228 CHECK_ERR(rval);
229
230 // Check for proper tag
231 rval = mb.tag_get_handle("T1", levels, MB_TYPE_DOUBLE, Ttag1);
232 CHECK_ERR(rval);
233 }
234
test_read_coord_vars()235 void test_read_coord_vars()
236 {
237 Core moab;
238 Interface& mb = moab;
239
240 EntityHandle file_set;
241 ErrorCode rval = mb.create_meshset(MESHSET_SET, file_set);
242 CHECK_ERR(rval);
243
244 std::string orig, opts;
245 get_options(orig);
246
247 opts = orig + std::string(";NOMESH;VARIABLE=");
248 rval = mb.load_file(example.c_str(), &file_set, opts.c_str());
249 CHECK_ERR(rval);
250
251 std::string tag_name;
252 int var_len;
253 Tag var_tag;
254 const void* var_data;
255
256 // Check tag for regular coordinate variable lev
257 tag_name = "lev";
258 var_len = 0;
259 rval = mb.tag_get_handle(tag_name.c_str(), var_len, MB_TYPE_OPAQUE, var_tag, MB_TAG_SPARSE | MB_TAG_VARLEN);
260 CHECK_ERR(rval);
261 CHECK_EQUAL(true, var_tag->variable_length());
262 CHECK_EQUAL(MB_TYPE_DOUBLE, var_tag->get_data_type());
263
264 // Check lev tag size and values on file_set
265 rval = mb.tag_get_by_ptr(var_tag, &file_set, 1, &var_data, &var_len);
266 CHECK_ERR(rval);
267 CHECK_EQUAL(levels, var_len);
268 double* lev_val = (double*)var_data;
269 const double eps = 1e-10;
270 CHECK_REAL_EQUAL(3.54463800000002, lev_val[0], eps);
271 CHECK_REAL_EQUAL(13.9672100000001, lev_val[levels - 1], eps);
272
273 // Check tag for dummy coordinate variable ncol
274 tag_name = "ncol";
275 var_len = 0;
276 rval = mb.tag_get_handle(tag_name.c_str(), var_len, MB_TYPE_OPAQUE, var_tag, MB_TAG_SPARSE | MB_TAG_VARLEN);
277 CHECK_ERR(rval);
278 CHECK_EQUAL(true, var_tag->variable_length());
279 CHECK_EQUAL(MB_TYPE_INTEGER, var_tag->get_data_type());
280
281 // Check ncol tag size and values on file_set
282 rval = mb.tag_get_by_ptr(var_tag, &file_set, 1, &var_data, &var_len);
283 CHECK_ERR(rval);
284 CHECK_EQUAL(1, var_len);
285 int* ncol_val = (int*)var_data;
286 CHECK_EQUAL(3458, ncol_val[0]);
287
288 // Create another file set
289 EntityHandle file_set2;
290 rval = mb.create_meshset(MESHSET_SET, file_set2);
291 CHECK_ERR(rval);
292
293 // Read file again with file_set2
294 rval = mb.load_file(example.c_str(), &file_set2, opts.c_str());
295 CHECK_ERR(rval);
296
297 // Check tag for regular coordinate lev
298 tag_name = "lev";
299 var_len = 0;
300 rval = mb.tag_get_handle(tag_name.c_str(), var_len, MB_TYPE_OPAQUE, var_tag, MB_TAG_SPARSE | MB_TAG_VARLEN);
301 CHECK_ERR(rval);
302 CHECK_EQUAL(true, var_tag->variable_length());
303 CHECK_EQUAL(MB_TYPE_DOUBLE, var_tag->get_data_type());
304
305 // Check lev tag size and values on file_set2
306 rval = mb.tag_get_by_ptr(var_tag, &file_set2, 1, &var_data, &var_len);
307 CHECK_ERR(rval);
308 CHECK_EQUAL(levels, var_len);
309 lev_val = (double*)var_data;
310 CHECK_REAL_EQUAL(3.54463800000002, lev_val[0], eps);
311 CHECK_REAL_EQUAL(13.9672100000001, lev_val[levels - 1], eps);
312
313 // Check tag for dummy coordinate variable ncol
314 tag_name = "ncol";
315 var_len = 0;
316 rval = mb.tag_get_handle(tag_name.c_str(), var_len, MB_TYPE_OPAQUE, var_tag, MB_TAG_SPARSE | MB_TAG_VARLEN);
317 CHECK_ERR(rval);
318 CHECK_EQUAL(true, var_tag->variable_length());
319 CHECK_EQUAL(MB_TYPE_INTEGER, var_tag->get_data_type());
320
321 // Check ncol tag size and values on file_set2
322 rval = mb.tag_get_by_ptr(var_tag, &file_set2, 1, &var_data, &var_len);
323 CHECK_ERR(rval);
324 CHECK_EQUAL(1, var_len);
325 ncol_val = (int*)var_data;
326 CHECK_EQUAL(3458, ncol_val[0]);
327 }
328
test_gather_onevar()329 void test_gather_onevar()
330 {
331 Core moab;
332 Interface& mb = moab;
333
334 EntityHandle file_set;
335 ErrorCode rval = mb.create_meshset(MESHSET_SET, file_set);
336 CHECK_ERR(rval);
337
338 std::string opts;
339 get_options(opts);
340
341 // Read vertex variable T and create gather set on processor 0
342 opts += ";VARIABLE=T;GATHER_SET=0";
343 #ifdef MOAB_HAVE_MPI
344 opts += ";PARALLEL_RESOLVE_SHARED_ENTS";
345 #endif
346 rval = mb.load_file(example.c_str(), &file_set, opts.c_str());
347 CHECK_ERR(rval);
348
349 #ifdef MOAB_HAVE_MPI
350 ParallelComm* pcomm = ParallelComm::get_pcomm(&mb, 0);
351 int rank = pcomm->proc_config().proc_rank();
352
353 Range verts, verts_owned;
354 rval = mb.get_entities_by_type(file_set, MBVERTEX, verts);
355 CHECK_ERR(rval);
356
357 // Get local owned vertices
358 rval = pcomm->filter_pstatus(verts, PSTATUS_NOT_OWNED, PSTATUS_NOT, -1, &verts_owned);
359 CHECK_ERR(rval);
360
361 EntityHandle gather_set = 0;
362 if (0 == rank) {
363 // Get gather set
364 ReadUtilIface* readUtilIface;
365 mb.query_interface(readUtilIface);
366 rval = readUtilIface->get_gather_set(gather_set);
367 CHECK_ERR(rval);
368 assert(gather_set != 0);
369 }
370
371 Tag Ttag0, gid_tag;
372 rval = mb.tag_get_handle("T0", levels, MB_TYPE_DOUBLE, Ttag0, MB_TAG_DENSE);
373 CHECK_ERR(rval);
374
375 rval = mb.tag_get_handle(GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, gid_tag, MB_TAG_DENSE);
376 CHECK_ERR(rval);
377
378 pcomm->gather_data(verts_owned, Ttag0, gid_tag, gather_set, 0);
379
380 if (0 == rank) {
381 // Get gather set vertices
382 Range gather_set_verts;
383 rval = mb.get_entities_by_type(gather_set, MBVERTEX, gather_set_verts);
384 CHECK_ERR(rval);
385 CHECK_EQUAL((size_t)3458, gather_set_verts.size());
386
387 // Get T0 tag values on 4 strategically selected gather set vertices
388 double T0_val[4 * levels];
389 EntityHandle vert_ents[] = {gather_set_verts[0], gather_set_verts[1728],
390 gather_set_verts[1729], gather_set_verts[3457]};
391 rval = mb.tag_get_data(Ttag0, vert_ents, 4, T0_val);
392 CHECK_ERR(rval);
393
394 const double eps = 0.001;
395
396 // Check first level values
397 CHECK_REAL_EQUAL(233.1136, T0_val[0 * levels], eps); // First vert
398 CHECK_REAL_EQUAL(236.1505, T0_val[1 * levels], eps); // Median vert
399 CHECK_REAL_EQUAL(235.7722, T0_val[2 * levels], eps); // Median vert
400 CHECK_REAL_EQUAL(234.0416, T0_val[3 * levels], eps); // Last vert
401 }
402 #endif
403 }
404
test_read_conn()405 void test_read_conn()
406 {
407 Core moab;
408 Interface& mb = moab;
409
410 std::string opts;
411 get_options(opts);
412
413 ErrorCode rval = mb.load_file(conn_fname.c_str(), NULL, opts.c_str());
414 CHECK_ERR(rval);
415
416 #ifdef MOAB_HAVE_MPI
417 ParallelComm* pcomm = ParallelComm::get_pcomm(&mb, 0);
418 int procs = pcomm->proc_config().proc_size();
419 #else
420 int procs = 1;
421 #endif
422
423 // Make check runs this test on one processor
424 if (1 == procs) {
425 // Get vertices
426 Range verts;
427 rval = mb.get_entities_by_type(0, MBVERTEX, verts);
428 CHECK_ERR(rval);
429 CHECK_EQUAL((size_t)3458, verts.size());
430
431 // Get cells
432 Range cells;
433 rval = mb.get_entities_by_type(0, MBQUAD, cells);
434 CHECK_ERR(rval);
435 CHECK_EQUAL((size_t)3456, cells.size());
436 }
437 }
438
get_options(std::string & opts)439 void get_options(std::string& opts)
440 {
441 #ifdef MOAB_HAVE_MPI
442 // Use parallel options
443 opts = std::string(";;PARALLEL=READ_PART;PARTITION_METHOD=TRIVIAL");
444 #else
445 opts = std::string(";;");
446 #endif
447 }
448