[5897] | 1 | #!/usr/bin/env python |
---|
| 2 | |
---|
| 3 | |
---|
| 4 | import unittest |
---|
| 5 | from math import sqrt, pi |
---|
| 6 | |
---|
| 7 | |
---|
| 8 | from anuga.config import epsilon |
---|
| 9 | from general_mesh import General_mesh |
---|
| 10 | from anuga.coordinate_transforms.geo_reference import Geo_reference |
---|
[7780] | 11 | from mesh_factory import rectangular |
---|
| 12 | from anuga.shallow_water.shallow_water_domain import Domain |
---|
[5897] | 13 | |
---|
[7276] | 14 | import numpy as num |
---|
[5897] | 15 | |
---|
| 16 | |
---|
| 17 | class Test_General_Mesh(unittest.TestCase): |
---|
| 18 | def setUp(self): |
---|
| 19 | pass |
---|
| 20 | |
---|
| 21 | def tearDown(self): |
---|
| 22 | pass |
---|
| 23 | |
---|
| 24 | |
---|
| 25 | def test_get_vertex_coordinates(self): |
---|
| 26 | from mesh_factory import rectangular |
---|
| 27 | |
---|
| 28 | #Create basic mesh |
---|
| 29 | nodes, triangles, _ = rectangular(1, 3) |
---|
| 30 | domain = General_mesh(nodes, triangles) |
---|
| 31 | |
---|
| 32 | |
---|
[6145] | 33 | assert num.allclose(domain.get_nodes(), nodes) |
---|
[5897] | 34 | |
---|
| 35 | |
---|
| 36 | M = domain.number_of_triangles |
---|
| 37 | |
---|
| 38 | V = domain.get_vertex_coordinates() |
---|
| 39 | assert V.shape[0] == 3*M |
---|
| 40 | |
---|
| 41 | for i in range(M): |
---|
| 42 | for j in range(3): |
---|
| 43 | k = triangles[i,j] #Index of vertex j in triangle i |
---|
[6145] | 44 | assert num.allclose(V[3*i+j,:], nodes[k]) |
---|
[5897] | 45 | |
---|
| 46 | def test_get_vertex_coordinates_with_geo_ref(self): |
---|
| 47 | x0 = 314036.58727982 |
---|
| 48 | y0 = 6224951.2960092 |
---|
| 49 | geo = Geo_reference(56, x0, y0) |
---|
| 50 | |
---|
| 51 | a = [0.0, 0.0] |
---|
| 52 | b = [0.0, 2.0] |
---|
| 53 | c = [2.0, 0.0] |
---|
| 54 | d = [0.0, 4.0] |
---|
| 55 | e = [2.0, 2.0] |
---|
| 56 | f = [4.0, 0.0] |
---|
[6145] | 57 | nodes = num.array([a, b, c, d, e, f]) |
---|
[5897] | 58 | |
---|
| 59 | nodes_absolute = geo.get_absolute(nodes) |
---|
| 60 | |
---|
[7276] | 61 | # bac, bce, ecf, dbe |
---|
| 62 | triangles = num.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]], num.int) |
---|
[5897] | 63 | |
---|
[7276] | 64 | domain = General_mesh(nodes, triangles, geo_reference=geo) |
---|
| 65 | |
---|
| 66 | verts = domain.get_vertex_coordinates(triangle_id=0) # bac |
---|
| 67 | msg = ("num.array([b,a,c])=\n%s\nshould be close to 'verts'=\n%s" |
---|
| 68 | % (str(num.array([b,a,c])), str(verts))) |
---|
| 69 | self.failUnless(num.allclose(num.array([b,a,c]), verts), msg) |
---|
| 70 | |
---|
[5897] | 71 | verts = domain.get_vertex_coordinates(triangle_id=0) |
---|
[7276] | 72 | msg = ("num.array([b,a,c])=\n%s\nshould be close to 'verts'=\n%s" |
---|
| 73 | % (str(num.array([b,a,c])), str(verts))) |
---|
| 74 | self.assert_(num.allclose(num.array([b,a,c]), verts), msg) |
---|
| 75 | |
---|
| 76 | verts = domain.get_vertex_coordinates(triangle_id=0, absolute=True) |
---|
| 77 | msg = ("num.array([...])=\n%s\nshould be close to 'verts'=\n%s" |
---|
| 78 | % (str(num.array([nodes_absolute[1], |
---|
| 79 | nodes_absolute[0], |
---|
| 80 | nodes_absolute[2]])), |
---|
| 81 | str(verts))) |
---|
[6145] | 82 | self.assert_(num.allclose(num.array([nodes_absolute[1], |
---|
[7276] | 83 | nodes_absolute[0], |
---|
| 84 | nodes_absolute[2]]), |
---|
| 85 | verts), msg) |
---|
| 86 | |
---|
[5897] | 87 | verts = domain.get_vertex_coordinates(triangle_id=0, |
---|
| 88 | absolute=True) |
---|
[7276] | 89 | msg = ("num.array([...])=\n%s\nshould be close to 'verts'=\n%s" |
---|
| 90 | % (str(num.array([nodes_absolute[1], |
---|
| 91 | nodes_absolute[0], |
---|
| 92 | nodes_absolute[2]])), |
---|
| 93 | str(verts))) |
---|
[6145] | 94 | self.assert_(num.allclose(num.array([nodes_absolute[1], |
---|
[7276] | 95 | nodes_absolute[0], |
---|
| 96 | nodes_absolute[2]]), |
---|
| 97 | verts), msg) |
---|
[5897] | 98 | |
---|
| 99 | def test_get_vertex_coordinates_triangle_id(self): |
---|
| 100 | """test_get_vertex_coordinates_triangle_id |
---|
| 101 | Test that vertices for one triangle can be returned. |
---|
| 102 | """ |
---|
| 103 | from mesh_factory import rectangular |
---|
| 104 | |
---|
| 105 | #Create basic mesh |
---|
| 106 | nodes, triangles, _ = rectangular(1, 3) |
---|
| 107 | domain = General_mesh(nodes, triangles) |
---|
| 108 | |
---|
| 109 | |
---|
[6145] | 110 | assert num.allclose(domain.get_nodes(), nodes) |
---|
[5897] | 111 | |
---|
| 112 | |
---|
| 113 | M = domain.number_of_triangles |
---|
| 114 | |
---|
| 115 | for i in range(M): |
---|
| 116 | V = domain.get_vertex_coordinates(triangle_id=i) |
---|
| 117 | assert V.shape[0] == 3 |
---|
| 118 | |
---|
| 119 | for j in range(3): |
---|
| 120 | k = triangles[i,j] #Index of vertex j in triangle i |
---|
[6145] | 121 | assert num.allclose(V[j,:], nodes[k]) |
---|
[5897] | 122 | |
---|
| 123 | |
---|
[7484] | 124 | def test_get_edge_midpoint_coordinates(self): |
---|
| 125 | from mesh_factory import rectangular |
---|
| 126 | |
---|
| 127 | #Create basic mesh |
---|
| 128 | nodes, triangles, _ = rectangular(1, 3) |
---|
| 129 | domain = General_mesh(nodes, triangles) |
---|
| 130 | |
---|
| 131 | |
---|
| 132 | assert num.allclose(domain.get_nodes(), nodes) |
---|
| 133 | |
---|
| 134 | |
---|
| 135 | M = domain.number_of_triangles |
---|
| 136 | |
---|
| 137 | E = domain.get_edge_midpoint_coordinates() |
---|
| 138 | assert E.shape[0] == 3*M |
---|
| 139 | |
---|
| 140 | for i in range(M): |
---|
| 141 | k0 = triangles[i,0] #Index of vertex 0 in triangle i |
---|
| 142 | k1 = triangles[i,1] #Index of vertex 1 in triangle i |
---|
| 143 | k2 = triangles[i,2] #Index of vertex 2 in triangle i |
---|
| 144 | |
---|
| 145 | assert num.allclose(E[3*i+0,:], 0.5*(nodes[k1]+nodes[k2]) ) |
---|
| 146 | assert num.allclose(E[3*i+1,:], 0.5*(nodes[k0]+nodes[k2]) ) |
---|
| 147 | assert num.allclose(E[3*i+2,:], 0.5*(nodes[k1]+nodes[k0]) ) |
---|
| 148 | |
---|
| 149 | def test_get_edge_midpoint_coordinates_with_geo_ref(self): |
---|
| 150 | x0 = 314036.58727982 |
---|
| 151 | y0 = 6224951.2960092 |
---|
| 152 | geo = Geo_reference(56, x0, y0) |
---|
[5897] | 153 | |
---|
[7484] | 154 | a = num.array([0.0, 0.0]) |
---|
| 155 | b = num.array([0.0, 2.0]) |
---|
| 156 | c = num.array([2.0, 0.0]) |
---|
| 157 | d = num.array([0.0, 4.0]) |
---|
| 158 | e = num.array([2.0, 2.0]) |
---|
| 159 | f = num.array([4.0, 0.0]) |
---|
| 160 | nodes = num.array([a, b, c, d, e, f]) |
---|
| 161 | |
---|
| 162 | nodes_absolute = geo.get_absolute(nodes) |
---|
[5897] | 163 | |
---|
[7484] | 164 | # bac, bce, ecf, dbe |
---|
| 165 | triangles = num.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]], num.int) |
---|
[5897] | 166 | |
---|
[7484] | 167 | domain = General_mesh(nodes, triangles, geo_reference=geo) |
---|
| 168 | |
---|
| 169 | verts = domain.get_edge_midpoint_coordinates(triangle_id=0) # bac |
---|
| 170 | msg = ("num.array(1/2[a+c,b+c,a+b])=\n%s\nshould be close to 'verts'=\n%s" |
---|
| 171 | % (str(num.array([0.5*(a+c),0.5*(b+c),0.5*(a+b)])), str(verts))) |
---|
| 172 | self.failUnless(num.allclose(num.array([0.5*(a+c),0.5*(b+c),0.5*(a+b)]), verts), msg) |
---|
| 173 | |
---|
| 174 | |
---|
| 175 | verts = domain.get_edge_midpoint_coordinates(triangle_id=0, absolute=True) |
---|
| 176 | msg = ("num.array([...])=\n%s\nshould be close to 'verts'=\n%s" |
---|
| 177 | % (str(0.5*num.array([nodes_absolute[0]+nodes_absolute[2], |
---|
| 178 | nodes_absolute[1]+nodes_absolute[2], |
---|
| 179 | nodes_absolute[1]+nodes_absolute[0]])), |
---|
| 180 | str(verts))) |
---|
| 181 | self.assert_(num.allclose(0.5*num.array([nodes_absolute[0]+nodes_absolute[2], |
---|
| 182 | nodes_absolute[1]+nodes_absolute[2], |
---|
| 183 | nodes_absolute[1]+nodes_absolute[0]]), |
---|
| 184 | verts), msg) |
---|
| 185 | |
---|
| 186 | def test_get_edge_midpoint_coordinates_triangle_id(self): |
---|
| 187 | """test_get_vertex_coordinates_triangle_id |
---|
| 188 | Test that vertices for one triangle can be returned. |
---|
| 189 | """ |
---|
| 190 | from mesh_factory import rectangular |
---|
| 191 | |
---|
| 192 | #Create basic mesh |
---|
| 193 | nodes, triangles, _ = rectangular(1, 3) |
---|
| 194 | domain = General_mesh(nodes, triangles) |
---|
| 195 | |
---|
| 196 | |
---|
| 197 | assert num.allclose(domain.get_nodes(), nodes) |
---|
| 198 | |
---|
| 199 | |
---|
| 200 | M = domain.number_of_triangles |
---|
| 201 | |
---|
| 202 | for i in range(M): |
---|
| 203 | E = domain.get_edge_midpoint_coordinates(triangle_id=i) |
---|
| 204 | assert E.shape[0] == 3 |
---|
| 205 | |
---|
| 206 | |
---|
| 207 | k0 = triangles[i,0] #Index of vertex 0 in triangle i |
---|
| 208 | k1 = triangles[i,1] #Index of vertex 0 in triangle i |
---|
| 209 | k2 = triangles[i,2] #Index of vertex 0 in triangle i |
---|
| 210 | |
---|
| 211 | assert num.allclose(E[0,:], 0.5*(nodes[k1]+nodes[k2])) |
---|
| 212 | assert num.allclose(E[1,:], 0.5*(nodes[k0]+nodes[k2])) |
---|
| 213 | assert num.allclose(E[2,:], 0.5*(nodes[k1]+nodes[k0])) |
---|
| 214 | |
---|
| 215 | E0 = domain.get_edge_midpoint_coordinate(i, 0 ) |
---|
| 216 | E1 = domain.get_edge_midpoint_coordinate(i, 1 ) |
---|
| 217 | E2 = domain.get_edge_midpoint_coordinate(i, 2 ) |
---|
| 218 | |
---|
| 219 | assert num.allclose(E0, 0.5*(nodes[k1]+nodes[k2])) |
---|
| 220 | assert num.allclose(E1, 0.5*(nodes[k0]+nodes[k2])) |
---|
| 221 | assert num.allclose(E2, 0.5*(nodes[k1]+nodes[k0])) |
---|
| 222 | |
---|
| 223 | |
---|
| 224 | |
---|
| 225 | |
---|
| 226 | |
---|
| 227 | |
---|
[5897] | 228 | def test_get_vertex_values(self): |
---|
| 229 | """Get connectivity based on triangle lists. |
---|
| 230 | """ |
---|
| 231 | from mesh_factory import rectangular |
---|
| 232 | |
---|
| 233 | #Create basic mesh |
---|
| 234 | nodes, triangles, _ = rectangular(1, 3) |
---|
| 235 | domain = General_mesh(nodes, triangles) |
---|
| 236 | |
---|
[7276] | 237 | msg = ("domain.get_triangles()=\n%s\nshould be the same as " |
---|
| 238 | "'triangles'=\n%s" |
---|
| 239 | % (str(domain.get_triangles()), str(triangles))) |
---|
| 240 | assert num.allclose(domain.get_triangles(), triangles), msg |
---|
| 241 | msg = ("domain.get_triangles([0,4])=\n%s\nshould be the same as " |
---|
| 242 | "'[triangles[0], triangles[4]]' which is\n%s" |
---|
| 243 | % (str(domain.get_triangles([0,4])), |
---|
| 244 | str([triangles[0], triangles[4]]))) |
---|
[6145] | 245 | assert num.allclose(domain.get_triangles([0,4]), |
---|
[7276] | 246 | [triangles[0], triangles[4]]), msg |
---|
[5897] | 247 | |
---|
| 248 | |
---|
| 249 | def test_vertex_value_indices(self): |
---|
| 250 | """Check that structures are correct. |
---|
| 251 | """ |
---|
| 252 | from mesh_factory import rectangular |
---|
| 253 | |
---|
| 254 | a = [0.0, 0.0] |
---|
| 255 | b = [0.0, 2.0] |
---|
| 256 | c = [2.0, 0.0] |
---|
| 257 | d = [0.0, 4.0] |
---|
| 258 | e = [2.0, 2.0] |
---|
| 259 | f = [4.0, 0.0] |
---|
| 260 | |
---|
[6145] | 261 | nodes = num.array([a, b, c, d, e, f]) |
---|
[5897] | 262 | #bac, bce, ecf, dbe, daf, dae |
---|
[6145] | 263 | triangles = num.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]]) |
---|
[5897] | 264 | |
---|
| 265 | domain1 = General_mesh(nodes, triangles) |
---|
| 266 | |
---|
| 267 | #Create larger mesh |
---|
| 268 | nodes, triangles, _ = rectangular(3, 6) |
---|
| 269 | domain2 = General_mesh(nodes, triangles) |
---|
| 270 | |
---|
| 271 | # Test both meshes |
---|
| 272 | for domain in [domain1, domain2]: |
---|
| 273 | assert sum(domain.number_of_triangles_per_node) ==\ |
---|
| 274 | len(domain.vertex_value_indices) |
---|
| 275 | |
---|
| 276 | # Check number of triangles per node |
---|
| 277 | count = [0]*domain.number_of_nodes |
---|
| 278 | for triangle in domain.triangles: |
---|
| 279 | for i in triangle: |
---|
| 280 | count[i] += 1 |
---|
| 281 | |
---|
| 282 | #print count |
---|
| 283 | # |
---|
[6145] | 284 | assert num.allclose(count, domain.number_of_triangles_per_node) |
---|
[5897] | 285 | |
---|
| 286 | # Check indices |
---|
| 287 | current_node = 0 |
---|
| 288 | k = 0 # Track triangles touching on node |
---|
| 289 | for index in domain.vertex_value_indices: |
---|
| 290 | k += 1 |
---|
| 291 | |
---|
| 292 | triangle = index / 3 |
---|
| 293 | vertex = index % 3 |
---|
| 294 | |
---|
| 295 | assert domain.triangles[triangle, vertex] == current_node |
---|
| 296 | |
---|
| 297 | if domain.number_of_triangles_per_node[current_node] == k: |
---|
| 298 | # Move on to next node |
---|
| 299 | k = 0 |
---|
| 300 | current_node += 1 |
---|
| 301 | |
---|
| 302 | |
---|
| 303 | def test_get_triangles_and_vertices_per_node(self): |
---|
| 304 | """test_get_triangles_and_vertices_per_node - |
---|
| 305 | |
---|
| 306 | Test that tuples of triangle, vertex can be extracted |
---|
| 307 | from inverted triangles structure |
---|
| 308 | |
---|
| 309 | """ |
---|
| 310 | |
---|
| 311 | a = [0.0, 0.0] |
---|
| 312 | b = [0.0, 2.0] |
---|
| 313 | c = [2.0, 0.0] |
---|
| 314 | d = [0.0, 4.0] |
---|
| 315 | e = [2.0, 2.0] |
---|
| 316 | f = [4.0, 0.0] |
---|
| 317 | |
---|
[6145] | 318 | nodes = num.array([a, b, c, d, e, f]) |
---|
[5897] | 319 | #bac, bce, ecf, dbe, daf, dae |
---|
[6145] | 320 | triangles = num.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]]) |
---|
[5897] | 321 | |
---|
| 322 | domain = General_mesh(nodes, triangles) |
---|
| 323 | |
---|
| 324 | # One node |
---|
| 325 | L = domain.get_triangles_and_vertices_per_node(node=2) |
---|
[6145] | 326 | assert num.allclose(L[0], [0, 2]) |
---|
| 327 | assert num.allclose(L[1], [1, 1]) |
---|
| 328 | assert num.allclose(L[2], [2, 1]) |
---|
[5897] | 329 | |
---|
| 330 | # All nodes |
---|
| 331 | ALL = domain.get_triangles_and_vertices_per_node() |
---|
| 332 | assert len(ALL) == 6 |
---|
| 333 | for i, Lref in enumerate(ALL): |
---|
| 334 | L = domain.get_triangles_and_vertices_per_node(node=i) |
---|
[6145] | 335 | assert num.allclose(L, Lref) |
---|
[5897] | 336 | |
---|
| 337 | |
---|
| 338 | |
---|
| 339 | |
---|
| 340 | |
---|
| 341 | |
---|
| 342 | |
---|
| 343 | def test_areas(self): |
---|
| 344 | #Create basic mesh |
---|
| 345 | points, vertices, boundary = rectangular(1, 3) |
---|
| 346 | domain = General_mesh(points, vertices) |
---|
| 347 | |
---|
| 348 | assert domain.get_area() == 1.0 |
---|
| 349 | |
---|
| 350 | |
---|
| 351 | def test_get_unique_vertex_values(self): |
---|
| 352 | """ |
---|
| 353 | get unique_vertex based on triangle lists. |
---|
| 354 | """ |
---|
| 355 | |
---|
| 356 | #Create basic mesh |
---|
| 357 | points, vertices, boundary = rectangular(1, 3) |
---|
| 358 | domain = General_mesh(points, vertices) |
---|
| 359 | |
---|
| 360 | assert domain.get_unique_vertices() == [0,1,2,3,4,5,6,7] |
---|
| 361 | unique_vertices = domain.get_unique_vertices([0,1,4]) |
---|
| 362 | unique_vertices.sort() |
---|
| 363 | assert unique_vertices == [0,1,2,4,5,6,7] |
---|
| 364 | |
---|
| 365 | unique_vertices = domain.get_unique_vertices([0,4]) |
---|
| 366 | unique_vertices.sort() |
---|
| 367 | assert unique_vertices == [0,2,4,5,6,7] |
---|
| 368 | |
---|
| 369 | def test_get_node(self): |
---|
| 370 | """test_get_triangles_and_vertices_per_node - |
---|
| 371 | |
---|
| 372 | Test that tuples of triangle, vertex can be extracted |
---|
| 373 | from inverted triangles structure |
---|
| 374 | |
---|
| 375 | """ |
---|
| 376 | |
---|
| 377 | x0 = 314036.58727982 |
---|
| 378 | y0 = 6224951.2960092 |
---|
| 379 | geo = Geo_reference(56, x0, y0) |
---|
| 380 | |
---|
| 381 | a = [0.0, 0.0] |
---|
| 382 | b = [0.0, 2.0] |
---|
| 383 | c = [2.0, 0.0] |
---|
| 384 | d = [0.0, 4.0] |
---|
| 385 | e = [2.0, 2.0] |
---|
| 386 | f = [4.0, 0.0] |
---|
| 387 | |
---|
[6145] | 388 | nodes = num.array([a, b, c, d, e, f]) |
---|
[5897] | 389 | |
---|
| 390 | nodes_absolute = geo.get_absolute(nodes) |
---|
| 391 | |
---|
[7276] | 392 | # bac, bce, ecf, dbe |
---|
[6145] | 393 | triangles = num.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]]) |
---|
[5897] | 394 | |
---|
[7276] | 395 | domain = General_mesh(nodes, triangles, geo_reference = geo) |
---|
[5897] | 396 | node = domain.get_node(2) |
---|
[7276] | 397 | msg = ('\nc=%s\nnode=%s' % (str(c), str(node))) |
---|
| 398 | self.failUnless(num.alltrue(c == node), msg) |
---|
| 399 | |
---|
| 400 | # repeat get_node(), see if result same |
---|
| 401 | node = domain.get_node(2) |
---|
| 402 | msg = ('\nc=%s\nnode=%s' % (str(c), str(node))) |
---|
| 403 | self.failUnless(num.alltrue(c == node), msg) |
---|
[5897] | 404 | |
---|
| 405 | node = domain.get_node(2, absolute=True) |
---|
[7276] | 406 | msg = ('\nnodes_absolute[2]=%s\nnode=%s' |
---|
| 407 | % (str(nodes_absolute[2]), str(node))) |
---|
| 408 | self.failUnless(num.alltrue(nodes_absolute[2] == node), msg) |
---|
| 409 | |
---|
| 410 | # repeat get_node(2, absolute=True), see if result same |
---|
[5897] | 411 | node = domain.get_node(2, absolute=True) |
---|
[7276] | 412 | msg = ('\nnodes_absolute[2]=%s\nnode=%s' |
---|
| 413 | % (str(nodes_absolute[2]), str(node))) |
---|
| 414 | self.failUnless(num.alltrue(nodes_absolute[2] == node), msg) |
---|
[5897] | 415 | |
---|
| 416 | |
---|
| 417 | def test_assert_index_in_nodes(self): |
---|
| 418 | """test_assert_index_in_nodes - |
---|
| 419 | |
---|
| 420 | Test that node indices in triangles are within nodes array. |
---|
| 421 | |
---|
| 422 | """ |
---|
| 423 | |
---|
| 424 | x0 = 314036.58727982 |
---|
| 425 | y0 = 6224951.2960092 |
---|
| 426 | geo = Geo_reference(56, x0, y0) |
---|
| 427 | |
---|
| 428 | a = [0.0, 0.0] |
---|
| 429 | b = [0.0, 2.0] |
---|
| 430 | c = [2.0, 0.0] |
---|
| 431 | d = [0.0, 4.0] |
---|
| 432 | e = [2.0, 2.0] |
---|
| 433 | f = [4.0, 0.0] |
---|
| 434 | |
---|
[6145] | 435 | nodes = num.array([a, b, c, d, e, f]) |
---|
[5897] | 436 | |
---|
| 437 | nodes_absolute = geo.get_absolute(nodes) |
---|
| 438 | |
---|
| 439 | # max index is 5, use 5, expect success |
---|
[6145] | 440 | triangles = num.array([[1,5,2], [1,2,4], [4,2,5], [3,1,4]]) |
---|
[5897] | 441 | General_mesh(nodes, triangles, geo_reference=geo) |
---|
| 442 | |
---|
| 443 | # max index is 5, use 6, expect assert failure |
---|
[6145] | 444 | triangles = num.array([[1,6,2], [1,2,4], [4,2,5], [3,1,4]]) |
---|
[5897] | 445 | self.failUnlessRaises(AssertionError, General_mesh, |
---|
| 446 | nodes, triangles, geo_reference=geo) |
---|
| 447 | |
---|
| 448 | # max index is 5, use 10, expect assert failure |
---|
[6145] | 449 | triangles = num.array([[1,10,2], [1,2,4], [4,2,5], [3,1,4]]) |
---|
[5897] | 450 | self.failUnlessRaises(AssertionError, General_mesh, |
---|
| 451 | nodes, triangles, geo_reference=geo) |
---|
| 452 | |
---|
[7276] | 453 | ################################################################################ |
---|
| 454 | |
---|
[5897] | 455 | if __name__ == "__main__": |
---|
[7484] | 456 | #suite = unittest.makeSuite(Test_General_Mesh, 'test') |
---|
| 457 | suite = unittest.makeSuite(Test_General_Mesh, 'test_get_edge_midpoint_coordinates') |
---|
[5897] | 458 | runner = unittest.TextTestRunner() |
---|
| 459 | runner.run(suite) |
---|
| 460 | |
---|