1 /*
2 MDAL - Mesh Data Abstraction Library (MIT License)
3 Copyright (C) 2019 Peter Petrik (zilolv at gmail dot com)
4 */
5 #include "gtest/gtest.h"
6 #include <string>
7 #include <vector>
8
9 //mdal
10 #include "mdal.h"
11 #include "mdal_testutils.hpp"
12
TEST(MeshTuflowFVTest,TrapSteady053D)13 TEST( MeshTuflowFVTest, TrapSteady053D )
14 {
15 std::string path = test_file( "/tuflowfv/withoutMaxes/trap_steady_05_3D.nc" );
16 EXPECT_EQ( MDAL_MeshNames( path.c_str() ), "TUFLOWFV:\"" + path + "\"" );
17 MDAL_MeshH m = MDAL_LoadMesh( path.c_str() );
18 EXPECT_NE( m, nullptr );
19 MDAL_Status s = MDAL_LastStatus();
20 ASSERT_EQ( MDAL_Status::None, s );
21
22 const char *projection = MDAL_M_projection( m );
23 std::string proj( projection );
24 EXPECT_TRUE( proj.find( "WGS_1984_UTM_ZONE_60S" ) != std::string::npos );
25
26 // ///////////
27 // Vertices
28 // ///////////
29 int v_count = MDAL_M_vertexCount( m );
30 EXPECT_EQ( v_count, 369 );
31
32 // ///////////
33 // Faces
34 // ///////////
35 int f_count = MDAL_M_faceCount( m );
36 EXPECT_EQ( 320, f_count );
37
38 // test face 1
39 int f_v_count = getFaceVerticesCountAt( m, 1 );
40 EXPECT_EQ( 4, f_v_count ); //quad
41 int f_v = getFaceVerticesIndexAt( m, 1, 0 );
42 EXPECT_EQ( 4, f_v );
43 f_v = getFaceVerticesIndexAt( m, 1, 1 );
44 EXPECT_EQ( 1, f_v );
45 f_v = getFaceVerticesIndexAt( m, 1, 2 );
46 EXPECT_EQ( 3, f_v );
47 f_v = getFaceVerticesIndexAt( m, 1, 3 );
48 EXPECT_EQ( 7, f_v );
49
50 ASSERT_EQ( 5, MDAL_M_datasetGroupCount( m ) );
51
52 // /////////////////////////////////
53 // Dataset: Bed Elevation
54 // /////////////////////////////////
55 {
56 MDAL_DatasetGroupH g = MDAL_M_datasetGroup( m, 0 );
57 ASSERT_NE( g, nullptr );
58
59 int meta_count = MDAL_G_metadataCount( g );
60 ASSERT_EQ( 1, meta_count );
61
62 const char *name = MDAL_G_name( g );
63 EXPECT_EQ( std::string( "Bed Elevation" ), std::string( name ) );
64
65 bool scalar = MDAL_G_hasScalarData( g );
66 EXPECT_EQ( true, scalar );
67
68 MDAL_DataLocation dataLocation = MDAL_G_dataLocation( g );
69 EXPECT_EQ( dataLocation, MDAL_DataLocation::DataOnVertices );
70
71 ASSERT_EQ( 1, MDAL_G_datasetCount( g ) );
72 MDAL_DatasetH ds = MDAL_G_dataset( g, 0 );
73 ASSERT_NE( ds, nullptr );
74
75 bool valid = MDAL_D_isValid( ds );
76 EXPECT_EQ( true, valid );
77
78 // check that 3D api returns zeroes
79 EXPECT_DOUBLE_EQ( 0, getValue3D( ds, 0 ) );
80 EXPECT_DOUBLE_EQ( 0, getValue3DX( ds, 0 ) );
81 EXPECT_DOUBLE_EQ( 0, getValue3DY( ds, 0 ) );
82 EXPECT_DOUBLE_EQ( -1, getLevelZ3D( ds, 0 ) );
83 EXPECT_EQ( -1, getLevelsCount3D( ds, 0 ) );
84 EXPECT_EQ( -1, get3DFrom2D( ds, 0 ) );
85
86 EXPECT_FALSE( MDAL_D_hasActiveFlagCapability( ds ) );
87
88 int count = MDAL_D_valueCount( ds );
89 ASSERT_EQ( 369, count );
90
91 double value = getValue( ds, 0 );
92 EXPECT_DOUBLE_EQ( -1.2562500238418579, value );
93
94 double min, max;
95 MDAL_D_minimumMaximum( ds, &min, &max );
96 EXPECT_DOUBLE_EQ( -5.9875001907348633, min );
97 EXPECT_DOUBLE_EQ( -1.25, max );
98
99 MDAL_G_minimumMaximum( g, &min, &max );
100 EXPECT_DOUBLE_EQ( -5.9875001907348633, min );
101 EXPECT_DOUBLE_EQ( -1.25, max );
102
103 EXPECT_EQ( 0, MDAL_D_maximumVerticalLevelCount( ds ) );
104 EXPECT_EQ( 0, MDAL_G_maximumVerticalLevelCount( g ) );
105
106 double time = MDAL_D_time( ds );
107 EXPECT_DOUBLE_EQ( 0.0, time );
108
109 EXPECT_FALSE( MDAL_G_isTemporal( g ) );
110 }
111
112 // /////////////////////////////////
113 // Dataset: scalar on volumes
114 // /////////////////////////////////
115 {
116 MDAL_DatasetGroupH g = MDAL_M_datasetGroup( m, 1 );
117 ASSERT_NE( g, nullptr );
118
119 int meta_count = MDAL_G_metadataCount( g );
120 ASSERT_EQ( 2, meta_count );
121
122 const char *name = MDAL_G_name( g );
123 EXPECT_EQ( std::string( "temperature" ), std::string( name ) );
124
125 bool scalar = MDAL_G_hasScalarData( g );
126 EXPECT_EQ( true, scalar );
127
128 MDAL_DataLocation dataLocation = MDAL_G_dataLocation( g );
129 EXPECT_EQ( dataLocation, MDAL_DataLocation::DataOnVolumes );
130
131 ASSERT_EQ( 37, MDAL_G_datasetCount( g ) );
132 MDAL_DatasetH ds = MDAL_G_dataset( g, 3 );
133 ASSERT_NE( ds, nullptr );
134
135 int maxLevels = MDAL_D_maximumVerticalLevelCount( ds );
136 EXPECT_EQ( maxLevels, 10 );
137
138 bool valid = MDAL_D_isValid( ds );
139 EXPECT_EQ( true, valid );
140
141 // check that 2D api returns zeroes
142 EXPECT_DOUBLE_EQ( 0, getValue( ds, 0 ) );
143 EXPECT_DOUBLE_EQ( 0, getValueX( ds, 0 ) );
144 EXPECT_DOUBLE_EQ( 0, getValueY( ds, 0 ) );
145
146 int index3d = get3DFrom2D( ds, 155 );
147 EXPECT_EQ( 1550, index3d );
148
149 int levelsCount = getLevelsCount3D( ds, 0 );
150 EXPECT_EQ( 10, levelsCount );
151
152 double levelZ1 = getLevelZ3D( ds, 0 );
153 EXPECT_DOUBLE_EQ( -1.2562493085861206, levelZ1 );
154
155 double levelZ2 = getLevelZ3D( ds, 11 );
156 EXPECT_DOUBLE_EQ( -3.333423376083374, levelZ2 );
157
158 double levelZ3 = getLevelZ3D( ds, 21 );
159 EXPECT_DOUBLE_EQ( -3.762500524520874, levelZ3 );
160
161 int count = MDAL_D_valueCount( ds );
162 ASSERT_EQ( 3200, count );
163
164 double value = getValue3D( ds, 222 );
165 EXPECT_DOUBLE_EQ( 0.49942651391029358, value );
166
167 double min, max;
168 MDAL_D_minimumMaximum( ds, &min, &max );
169 EXPECT_DOUBLE_EQ( 0, min );
170 EXPECT_DOUBLE_EQ( 33.165805816650391, max );
171
172 MDAL_G_minimumMaximum( g, &min, &max );
173 EXPECT_DOUBLE_EQ( 0, min );
174 EXPECT_DOUBLE_EQ( 34.741443634033203, max );
175
176 EXPECT_EQ( 10, MDAL_D_maximumVerticalLevelCount( ds ) );
177 EXPECT_EQ( 10, MDAL_G_maximumVerticalLevelCount( g ) );
178
179 double time = MDAL_D_time( ds );
180 EXPECT_TRUE( compareDurationInHours( 0.502121734619141, time ) );
181 EXPECT_TRUE( compareReferenceTime( g, "1990-01-01T00:00:00" ) );
182 }
183
184 // /////////////////////////////////
185 // Dataset: vector on volumes
186 // /////////////////////////////////
187 {
188 MDAL_DatasetGroupH g = MDAL_M_datasetGroup( m, 2 );
189 ASSERT_NE( g, nullptr );
190
191 int meta_count = MDAL_G_metadataCount( g );
192 ASSERT_EQ( 2, meta_count );
193
194 const char *name = MDAL_G_name( g );
195 EXPECT_EQ( std::string( "velocity" ), std::string( name ) );
196
197 bool scalar = MDAL_G_hasScalarData( g );
198 EXPECT_EQ( false, scalar );
199
200 MDAL_DataLocation dataLocation = MDAL_G_dataLocation( g );
201 EXPECT_EQ( dataLocation, MDAL_DataLocation::DataOnVolumes );
202
203 ASSERT_EQ( 37, MDAL_G_datasetCount( g ) );
204 MDAL_DatasetH ds = MDAL_G_dataset( g, 4 );
205 ASSERT_NE( ds, nullptr );
206
207 bool valid = MDAL_D_isValid( ds );
208 EXPECT_EQ( true, valid );
209
210 int active = getActive( ds, 0 );
211 EXPECT_EQ( 0, active ); // edge values is inactive
212
213 active = getActive( ds, 200 );
214 EXPECT_EQ( 1, active ); // middle values is active
215
216 int count = MDAL_D_valueCount( ds );
217 ASSERT_EQ( 3200, count );
218
219 int volumes = MDAL_D_volumesCount( ds );
220 ASSERT_EQ( 3200, volumes );
221
222 double valueX = getValue3DX( ds, 444 );
223 EXPECT_DOUBLE_EQ( 0.0, valueX );
224
225 double valueY = getValue3DY( ds, 444 );
226 EXPECT_DOUBLE_EQ( 0.0, valueY );
227
228 double min, max;
229 MDAL_D_minimumMaximum( ds, &min, &max );
230 EXPECT_DOUBLE_EQ( 0, min );
231 EXPECT_DOUBLE_EQ( 1.2225217354813651, max );
232
233 MDAL_G_minimumMaximum( g, &min, &max );
234 EXPECT_DOUBLE_EQ( 0, min );
235 EXPECT_DOUBLE_EQ( 1.7670363355554111, max );
236
237 double time = MDAL_D_time( ds );
238 EXPECT_TRUE( compareDurationInHours( 0.667265041139391, time ) );
239 EXPECT_TRUE( compareReferenceTime( g, "1990-01-01T00:00:00" ) );
240
241 EXPECT_TRUE( MDAL_G_isTemporal( g ) );
242 }
243
244 // /////////////////////////////////
245 // Dataset: scalar on faces
246 // /////////////////////////////////
247 {
248 MDAL_DatasetGroupH g = MDAL_M_datasetGroup( m, 3 );
249 ASSERT_NE( g, nullptr );
250
251 int meta_count = MDAL_G_metadataCount( g );
252 ASSERT_EQ( 2, meta_count );
253
254 const char *name = MDAL_G_name( g );
255 EXPECT_EQ( std::string( "water depth" ), std::string( name ) );
256
257 bool scalar = MDAL_G_hasScalarData( g );
258 EXPECT_EQ( true, scalar );
259
260 MDAL_DataLocation dataLocation = MDAL_G_dataLocation( g );
261 EXPECT_EQ( dataLocation, MDAL_DataLocation::DataOnFaces );
262
263 ASSERT_EQ( 37, MDAL_G_datasetCount( g ) );
264 MDAL_DatasetH ds = MDAL_G_dataset( g, 7 );
265 ASSERT_NE( ds, nullptr );
266
267 bool valid = MDAL_D_isValid( ds );
268 EXPECT_EQ( true, valid );
269
270 int active = getActive( ds, 0 );
271 EXPECT_EQ( 0, active );
272
273 active = getActive( ds, 200 );
274 EXPECT_EQ( 1, active );
275
276 int count = MDAL_D_valueCount( ds );
277 ASSERT_EQ( 320, count );
278
279 double value = getValue( ds, 789 );
280 EXPECT_DOUBLE_EQ( 0.0, value );
281
282 double min, max;
283 MDAL_D_minimumMaximum( ds, &min, &max );
284 EXPECT_DOUBLE_EQ( 0.35393771529197693, min );
285 EXPECT_DOUBLE_EQ( 2.4886724948883057, max );
286
287 MDAL_G_minimumMaximum( g, &min, &max );
288 EXPECT_DOUBLE_EQ( 0.25624990463256836, min );
289 EXPECT_DOUBLE_EQ( 2.488835334777832, max );
290
291 double time = MDAL_D_time( ds );
292 EXPECT_TRUE( compareDurationInHours( 1.16755709277259, time ) );
293 EXPECT_TRUE( compareReferenceTime( g, "1990-01-01T00:00:00" ) );
294
295 EXPECT_TRUE( MDAL_G_isTemporal( g ) );
296 }
297
298 // Close mesh
299 MDAL_CloseMesh( m );
300 }
301
TEST(MeshTuflowFVTest,TrapSteady053DWithMaxes)302 TEST( MeshTuflowFVTest, TrapSteady053DWithMaxes )
303 {
304 std::string path = test_file( "/tuflowfv/withMaxes/trap_steady_05_3D.nc" );
305 EXPECT_EQ( MDAL_MeshNames( path.c_str() ), "TUFLOWFV:\"" + path + "\"" );
306 MDAL_MeshH m = MDAL_LoadMesh( path.c_str() );
307 EXPECT_NE( m, nullptr );
308 MDAL_Status s = MDAL_LastStatus();
309 ASSERT_EQ( MDAL_Status::None, s );
310
311 const char *projection = MDAL_M_projection( m );
312 EXPECT_EQ( std::string( "" ), std::string( projection ) );
313
314 // ///////////
315 // Vertices
316 // ///////////
317 int v_count = MDAL_M_vertexCount( m );
318 EXPECT_EQ( v_count, 369 );
319
320 // ///////////
321 // Faces
322 // ///////////
323 int f_count = MDAL_M_faceCount( m );
324 EXPECT_EQ( 320, f_count );
325
326 ASSERT_EQ( 21, MDAL_M_datasetGroupCount( m ) );
327
328 // /////////////////////////////////
329 // Dataset: maximums dataset
330 // /////////////////////////////////
331 {
332 MDAL_DatasetGroupH g = MDAL_M_datasetGroup( m, 2 );
333 ASSERT_NE( g, nullptr );
334
335 int meta_count = MDAL_G_metadataCount( g );
336 ASSERT_EQ( 2, meta_count );
337
338 const char *name = MDAL_G_name( g );
339 EXPECT_EQ( std::string( "temperature/Maximums" ), std::string( name ) );
340
341 bool scalar = MDAL_G_hasScalarData( g );
342 EXPECT_EQ( true, scalar );
343
344 MDAL_DataLocation dataLocation = MDAL_G_dataLocation( g );
345 EXPECT_EQ( dataLocation, MDAL_DataLocation::DataOnVolumes );
346
347 ASSERT_EQ( 1, MDAL_G_datasetCount( g ) );
348 MDAL_DatasetH ds = MDAL_G_dataset( g, 0 );
349 ASSERT_NE( ds, nullptr );
350
351 double min, max;
352 MDAL_D_minimumMaximum( ds, &min, &max );
353 EXPECT_DOUBLE_EQ( 4.9999990463256836, min );
354 EXPECT_DOUBLE_EQ( 5.0003223419189453, max );
355
356 MDAL_G_minimumMaximum( g, &min, &max );
357 EXPECT_DOUBLE_EQ( 4.9999990463256836, min );
358 EXPECT_DOUBLE_EQ( 5.0003223419189453, max );
359
360 double time = MDAL_D_time( ds );
361 EXPECT_DOUBLE_EQ( 0, time );
362 EXPECT_TRUE( compareReferenceTime( g, "1990-01-01T00:00:00" ) );
363
364 EXPECT_FALSE( MDAL_G_isTemporal( g ) );
365 }
366
367
368 // Close mesh
369 MDAL_CloseMesh( m );
370 }
371
main(int argc,char ** argv)372 int main( int argc, char **argv )
373 {
374 testing::InitGoogleTest( &argc, argv );
375 init_test();
376 int ret = RUN_ALL_TESTS();
377 finalize_test();
378 return ret;
379 }
380