diff --git a/bin/grid_regular.py b/bin/grid_regular.py index be72b66..e055e06 100755 --- a/bin/grid_regular.py +++ b/bin/grid_regular.py @@ -2,6 +2,7 @@ import sys import pickle +import pdb from grid.DD import rect_grid, random_grid from baker import run_baker diff --git a/lib/baker/__init__.py b/lib/baker/__init__.py index b82ceac..1efcab3 100644 --- a/lib/baker/__init__.py +++ b/lib/baker/__init__.py @@ -102,7 +102,7 @@ def qlinear_3D(X, R): qlin = sum([q_i * phi_i for q_i, phi_i in zip(R.q, phis)]) return phis, qlin -def run_baker(X, R, S): +def run_baker(X, R, S, order=2): """ This is the main function to call to get an interpolation to X from the input meshes diff --git a/lib/grid/__init__.py b/lib/grid/__init__.py index ac0095f..dd92f54 100644 --- a/lib/grid/__init__.py +++ b/lib/grid/__init__.py @@ -88,9 +88,9 @@ class grid(object): (dist, indicies) = self.tree.query(X, 2) simplex = None - for i in self.facets_for_point[indicies[0]]: - if i.contains(X, self): - simplex = i + for facet in self.facets_for_point[indicies[0]]: + if facet.contains(X, self): + simplex = facet break if not simplex: diff --git a/lib/grid/simplex.py b/lib/grid/simplex.py index 046496d..40f60c4 100644 --- a/lib/grid/simplex.py +++ b/lib/grid/simplex.py @@ -1,13 +1,17 @@ from baker import get_phis -TOL = 1e-3 +TOL = 1e-8 def contains(X, R): - phis = get_phis(X, R) - r = True - if [i for i in phis if i < 0.0 - TOL]: - r = False - return r + """ + tests if X (point) is in R (a simplex, + represented by a list of n-degree coordinates) + """ + phis = get_phis(X, R) + r = True + if [i for i in phis if i < 0.0 - TOL]: + r = False + return r class face(object): @@ -28,8 +32,18 @@ class face(object): """ self.neighbors.append(n) - def contains(self, X, grid): - return contains(X, grid.points) + def contains(self, X, G): + """ + X = point of interest + G = corrensponding grid object (G.points) + because of the way i'm storing things, + a face simply stores indicies, and so one + must pass in a reference to the grid object + containing real points. + + this simply calls grid.simplex.contains + """ + return contains(X, [G.points[i] for i in self.verts]) def __str__(self): neighbors = [i.name for i in self.neighbors] diff --git a/test/baker.test.py b/test/baker.test.py index 7808f4d..3c1382d 100755 --- a/test/baker.test.py +++ b/test/baker.test.py @@ -37,12 +37,12 @@ class TestSequenceFunctions(unittest.TestCase): r = [[-1, -1], [0, 2], [1, -1]] result = baker.get_phis(X, r) - result = [round(i, self.accuracy) for i in result] +#result = [round(i, self.accuracy) for i in result] - right_answer = [round(i, self.accuracy) for i in [1/3.0, 1/3.0, 1/3.0]] + right_answer = [1/3.0, 1/3.0, 1/3.0] for a,b in zip(result, right_answer): - self.assertEqual(a,b) + self.assertAlmostEqual(a,b) def testGetPhis2(self): @@ -78,13 +78,13 @@ class TestSequenceFunctions(unittest.TestCase): self.q[size_of_simplex:size_of_simplex + extra_points]) answer = baker.run_baker(self.X, R, S) - a = round(answer['a'], self.accuracy) - b = round(answer['b'], self.accuracy) - c = round(answer['c'], self.accuracy) + a = answer['a'] + b = answer['b'] + c = answer['c'] - self.assertEqual(a, c) - self.assertEqual(c, round(0.00 , self.accuracy)) - self.assertEqual(b, round(1/3.0, self.accuracy)) + self.assertAlmostEqual(a, c) + self.assertAlmostEqual(c, 0.0) + self.assertAlmostEqual(b, 1/3.0) def testRunBaker_2(self): size_of_simplex = 3 @@ -98,12 +98,12 @@ class TestSequenceFunctions(unittest.TestCase): answer = baker.run_baker(self.X, R, S) - a = round(answer['a'], 5) - b = round(answer['b'], 5) - c = round(answer['c'], 5) + a = answer['a'] + b = answer['b'] + c = answer['c'] - self.assertEqual(a, c) - self.assertEqual(c, round(float(2/3.0), 5)) + self.assertAlmostEqual(a, c) + self.assertAlmostEqual(c, 2/3.0) def testRunBaker_3(self): size_of_simplex = 3 @@ -116,13 +116,13 @@ class TestSequenceFunctions(unittest.TestCase): self.q[size_of_simplex:size_of_simplex + extra_points]) answer = baker.run_baker(self.X, R, S) - a = round(answer['a'], 5) - b = round(answer['b'], 5) - c = round(answer['c'], 5) + a = answer['a'] + b = answer['b'] + c = answer['c'] - self.assertEqual(a, round(float(13/14.0), 5)) - self.assertEqual(b, round(float(2 / 7.0), 5)) - self.assertEqual(c, round(float(15/14.0), 5)) + self.assertAlmostEqual(a, 13/14.0) + self.assertAlmostEqual(b, 2 / 7.0) + self.assertAlmostEqual(c, 15/14.0) def testRunBaker_4(self): size_of_simplex = 3 @@ -135,13 +135,13 @@ class TestSequenceFunctions(unittest.TestCase): self.q[size_of_simplex:size_of_simplex + extra_points]) answer = baker.run_baker(self.X, R, S) - a = round(answer['a'], 5) - b = round(answer['b'], 5) - c = round(answer['c'], 5) + a = answer['a'] + b = answer['b'] + c = answer['c'] - self.assertEqual(a, round(float(48/53.0), 5)) - self.assertEqual(b, round(float(15/53.0), 5)) - self.assertEqual(c, round(float(54/53.0), 5)) + self.assertAlmostEqual(a, 48/53.0) + self.assertAlmostEqual(b, 15/53.0) + self.assertAlmostEqual(c, 54/53.0) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(TestSequenceFunctions) diff --git a/test/baker3D.test.py b/test/baker3D.test.py index af172c9..bf2e6d7 100755 --- a/test/baker3D.test.py +++ b/test/baker3D.test.py @@ -20,17 +20,18 @@ class TestSequenceFunctions(unittest.TestCase): def testGetPhis3D(self): - result = [round(i, 5) for i in baker.get_phis_3D(self.X, self.r)] - right_answer = [round(i, 5) for i in [0.25, 0.25, 0.25, 0.25]] + result = baker.get_phis_3D(self.X, self.r) + right_answer = [0.25, 0.25, 0.25, 0.25] - self.assertEqual(result, right_answer) + for a,b in zip(result, right_answer): + self.assertAlmostEqual(a,b) def testQlinear3D(self): phi, result = baker.qlinear_3D(self.X, grid.grid(self.r, self.q)) - result = round(result, 5) - right_answer = round(1.0, 5) - self.assertEqual(result, right_answer) + result = result + right_answer = 1.0 + self.assertAlmostEqual(result, right_answer) if __name__ == '__main__': diff --git a/test/quad.test.py b/test/quad.test.py index df02a61..ea8f67e 100755 --- a/test/quad.test.py +++ b/test/quad.test.py @@ -2,12 +2,17 @@ import unittest +import math + from baker import run_baker -from baker.tools import exact_func from grid.DD import grid from grid.simplex import contains +def exact_func(X): + x = X[0] + y = X[0] + return 1 - math.sin((x-0.5)**2 + (y-0.5)**2) class TestSequenceFunctions(unittest.TestCase): def setUp(self): @@ -23,31 +28,51 @@ class TestSequenceFunctions(unittest.TestCase): ] self.q = [exact_func(p) for p in self.points] - self.X = [0.55, 0.45] self.X = [0.25, 0.4001] + self.X = [0.55, 0.45] self.g = grid(self.points, self.q) self.g.construct_connectivity() self.R = self.g.create_mesh(range(3)) - self.S = self.g.create_mesh(range(3,len(self.points))) self.exact = exact_func(self.X) - self.answer = run_baker(self.X, self.R, self.S) self.accuracy = 8 def test_R_contains_X(self): self.assertTrue(contains(self.X, self.R.points)) - def test_RunBaker(self): - print - print "X\n", self.X - print "R\n", self.R - print "S\n", self.S - print "exact\n",self.exact - print "qlin\n",self.answer['qlin'] - self.assertTrue(self.answer) + def test_RunBaker_1_extra_point(self, extra=1): + S = self.g.create_mesh(range(3, 3 + extra)) + answer = run_baker(self.X, self.R, S) + lin_err = abs(self.exact - answer['qlin']) + final_err = abs(self.exact - answer['final']) + self.assertTrue(lin_err >= final_err) + def test_RunBaker_2_extra_point(self, extra=2): + S = self.g.create_mesh(range(3, 3 + extra)) + answer = run_baker(self.X, self.R, S) + lin_err = abs(self.exact - answer['qlin']) + final_err = abs(self.exact - answer['final']) + self.assertTrue(lin_err >= final_err) + def test_RunBaker_3_extra_point(self, extra=3): + S = self.g.create_mesh(range(3, 3 + extra)) + answer = run_baker(self.X, self.R, S) + lin_err = abs(self.exact - answer['qlin']) + final_err = abs(self.exact - answer['final']) + self.assertTrue(lin_err >= final_err) + def test_RunBaker_4_extra_point(self, extra=4): + S = self.g.create_mesh(range(3, 3 + extra)) + answer = run_baker(self.X, self.R, S) + lin_err = abs(self.exact - answer['qlin']) + final_err = abs(self.exact - answer['final']) + self.assertTrue(lin_err >= final_err) + def test_RunBaker_5_extra_point(self, extra=5): + S = self.g.create_mesh(range(3, 3 + extra)) + answer = run_baker(self.X, self.R, S) + lin_err = abs(self.exact - answer['qlin']) + final_err = abs(self.exact - answer['final']) + self.assertTrue(lin_err >= final_err) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(TestSequenceFunctions)