sm/smbinterp
1
0
Fork 0
Code Issues Pull Requests Activity

created a test for tesing the cubic interpolation

Browse Source
This commit is contained in:
Stephen Mardson McQuay 2010-03-20 20:09:46 -06:00
parent 1fc988428d
commit 700ccc8c25
7 changed files with 97 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
bin/grid_regular.py
View File

@ -2,6 +2,7 @@
import sys
import pickle
import pdb
from grid.DD import rect_grid, random_grid
from baker import run_baker

2
lib/baker/__init__.py
View File

@ -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

6
lib/grid/__init__.py
View File

@ -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:

20
lib/grid/simplex.py
View File

@ -1,8 +1,12 @@
from baker import get_phis
TOL = 1e-3
TOL = 1e-8
def contains(X, 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]:
@ -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]

52
test/baker.test.py
View File

@ -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)

13
test/baker3D.test.py
View File

@ -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__':

49
test/quad.test.py
View File

@ -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)