Browse Source

working on getting baker to work in 3D. the code runs, but the numbers are odd. I suspect the rectangular grid, and am going to try a random cloud of points.

master
Stephen Mardson McQuay 12 years ago
parent
commit
b33159f8a9
  1. 1
      .setup
  2. 22
      bin/driver.py
  3. 4
      bin/grid_regular.py
  4. 113
      lib/baker/baker.py
  5. 9
      lib/baker/tools.py
  6. 109
      lib/grid/grid.py
  7. 2
      setup.py
  8. 47
      test/baker.test.py

1
.setup

@ -1,2 +1 @@
export PATH=$PWD/bin:$PWD/test:$PATH
export PYTHONPATH=$PWD/lib

22
bin/driver.py

@ -6,18 +6,18 @@ from optparse import OptionParser
import numpy as np
from baker.tools import rms, exact_func
import grid
from grid.DD import simple_random_grid, simple_rect_grid
def get_mesh(source, destination, use_structured_grid = False):
mesh_source = None
mesh_dest = None
if use_structured_grid:
mesh_source = grid.simple_rect_grid(source, source)
mesh_dest = grid.simple_rect_grid(destination, destination)
mesh_source = simple_rect_grid(source, source)
mesh_dest = simple_rect_grid(destination, destination)
else:
mesh_source = grid.simple_random_grid(source)
mesh_dest = grid.simple_random_grid(destination)
mesh_source = simple_random_grid(source)
mesh_dest = simple_random_grid(destination)
if not (mesh_dest and mesh_source):
raise smberror('problem creating mesh objects')
@ -39,35 +39,33 @@ if __name__ == '__main__':
dest="extra",
type='int',
default = 3,
help = "how many extra points")
help = "how many extra points (%default)")
parser.add_option("-s",
"--source-total",
dest="source_total",
type='int',
default = 100,
help = "total number of source points for random,\
resolution for structured")
help = "total number of source points for random, resolution for structured (%default)")
parser.add_option("-d",
"--destination-total",
dest="destination_total",
type='int',
default = 100,
help = "total number of destination points,\
resolution for structured")
help = "total number of destination points, resolution for structured (%default)")
parser.add_option("-r",
"--structured",
action = 'store_true',
default = False,
help = "use a structured grid instead of random point cloud")
help = "use a structured grid instead of random point cloud (%default)")
parser.add_option("-v",
"--verbose",
action = 'store_true',
default = False,
help = "verbosity")
help = "verbosity (%default)")
(options, args) = parser.parse_args()

4
bin/grid_regular.py

@ -1,9 +1,9 @@
#!/usr/bin/python
#!/usr/bin/python2.6
import sys
import pickle
from grid import simple_rect_grid, simple_random_grid
from grid.DD import simple_rect_grid, simple_random_grid
from baker import run_baker
from baker.tools import smberror

113
lib/baker/baker.py

@ -41,9 +41,14 @@ def get_phis_3D(X, r):
X -- the destination point (3D)
X = [0,0,0]
r -- the four points that make up the tetrahedron (3D)
r = [[-1, -1], [0, 2], [1, -1]]
this will return [0.333, 0.333, 0.333]
r = [
[0.0, 0.0, 1.0],
[0.94280904333606508, 0.0, -0.3333333283722672],
[-0.47140452166803232, 0.81649658244673617, -0.3333333283722672],
[-0.47140452166803298, -0.81649658244673584, -0.3333333283722672],
]
this will return [0.25, 0.25, 0.25, 0.25]
"""
# baker: eq 7
@ -82,7 +87,7 @@ def qlinear(X, R):
qlin = sum([q_i * phi_i for q_i, phi_i in zip(R.q, phis)])
return phis, qlin
def qlinear_3D(X, R, q):
def qlinear_3D(X, R):
"""
this calculates the linear portion of q from X to r
@ -91,8 +96,8 @@ def qlinear_3D(X, R, q):
q = CFD quantities of interest at the simplex points(R)
"""
phis = get_phis_3D(X, R)
qlin = sum([q_i * phi_i for q_i, phi_i in zip(q, phis)])
phis = get_phis_3D(X, R.points)
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):
@ -103,13 +108,11 @@ def run_baker(X, R, S):
X = [0,0]
R = Simplex
S = extra points
"""
# calculate values only for the triangle
phi, qlin = qlinear (X, R)
phi, qlin = qlinear(X, R)
if len(S.points) == 0:
answer = {
@ -129,7 +132,13 @@ def run_baker(X, R, S):
cur_phi, cur_qlin = qlinear(s, R)
(phi1, phi2, phi3) = cur_phi
B.append([phi1 * phi2, phi2 * phi3, phi3 * phi1])
B.append(
[
phi1 * phi2,
phi2 * phi3,
phi3 * phi1,
]
)
w.append(q - cur_qlin)
B = np.array(B)
@ -161,3 +170,87 @@ def run_baker(X, R, S):
}
return answer
def run_baker_3D(X, R, S):
"""
This is the main function to call to get an interpolation to X from the input meshes
X -- the destination point (3D)
X = [0,0,0]
R = Simplex (4 points, contains X)
S = extra points (surrounding, in some manner, R and X, but not in R)
"""
# calculate values only for the triangle
phi, qlin = qlinear_3D(X, R)
if len(S.points) == 0:
answer = {
'a': None,
'b': None,
'c': None,
'd': None,
'e': None,
'f': None,
'qlin': qlin,
'error': None,
'final': None,
}
return answer
B = [] # baker eq 9
w = [] # baker eq 11
for (s, q) in zip(S.points, S.q):
cur_phi, cur_qlin = qlinear_3D(s, R)
(phi1, phi2, phi3, phi4) = cur_phi
B.append(
[
phi1 * phi2,
phi1 * phi3,
phi1 * phi4,
phi2 * phi3,
phi2 * phi4,
phi3 * phi4,
]
)
w.append(q - cur_qlin)
B = np.array(B)
w = np.array(w)
A = np.dot(B.T, B)
b = np.dot(B.T, w)
# baker solve eq 10
try:
(a, b, c, d, e, f) = np.linalg.solve(A,b)
except:
print >> sys.stderr, "warning: run_baker: linear calculation went bad, resorting to np.linalg.pinv"
(a, b, c, d, e, f) = np.dot(np.linalg.pinv(A), b)
error_term = a * phi[0] * phi[1]\
+ b * phi[0] * phi[2]\
+ c * phi[0] * phi[3]\
+ d * phi[1] * phi[2]\
+ e * phi[1] * phi[3]\
+ f * phi[2] * phi[3]
q_final = qlin + error_term
answer = {
'a': a,
'b': b,
'c': c,
'd': d,
'e': e,
'f': f,
'qlin': qlin,
'error': error_term,
'final': q_final,
}
return answer

9
lib/baker/tools.py

@ -24,3 +24,12 @@ def exact_func(x, y):
the exact function used from baker's article (for testing)
"""
return np.power((np.sin(x * np.pi) * np.cos(y * np.pi)), 2)
def exact_func_3D(X):
"""
the exact function (3D) used from baker's article (for testing)
"""
x = X[0]
y = X[1]
z = X[2]
return np.power((np.sin(x * np.pi / 2.0) * np.sin(y * np.pi / 2.0) * np.sin(z * np.pi / 2.0)), 2)

109
lib/grid/grid.py

@ -7,49 +7,11 @@ from collections import defaultdict
import numpy as np
import scipy.spatial
from baker import run_baker, get_phis
from baker import run_baker
from baker.tools import exact_func, smberror
from simplex import face
from smcqdelaunay import *
class face(object):
def __init__(self, name):
self.name = name
self.verts = []
self.neighbors = []
def add_vert(self, v):
"""
v should be an index into grid.points
"""
self.verts.append(v)
def add_neighbor(self, n):
"""
reference to another face object
"""
self.neighbors.append(n)
def contains(self, X, grid):
R = [grid.points[i] for i in self.verts]
phis = get_phis(X, R)
r = True
if [i for i in phis if i < 0.0]:
r = False
return r
def __str__(self):
neighbors = [i.name for i in self.neighbors]
return '%s: verts: %s neighbors: [%s]' %\
(
self.name,
self.verts,
", ".join(neighbors)
)
class grid(object):
@ -97,7 +59,7 @@ class grid(object):
R is a grid object that is the (a) containing simplex around point X
S is S_j from baker's paper : some points from all point that are not the simplex
"""
(dist, indicies) = self.tree.query(X, 3 + extra_points)
(dist, indicies) = self.tree.query(X, simplex_size + extra_points)
# get the containing simplex
@ -152,7 +114,7 @@ class grid(object):
try:
(R, S) = self.get_simplex_and_nearest_points(X)
answer = run_baker(X, R, S)
except smberror as e:
except smberror, e:
print "caught error: %s, trying with connectivity-based mesh" % e
(R, S) = self.get_points_conn(X)
answer = run_baker(X, R, S)
@ -199,27 +161,6 @@ class grid(object):
# self.facets_for_point[int(point[1:])] = [i for i in neighboring_facets.split() if i in self.faces]
def for_qhull_generator(self):
"""
this returns a generator that should be fed into qdelaunay
"""
yield '2';
yield '%d' % len(self.points)
for p in self.points:
yield "%f %f" % (p[0], p[1])
def for_qhull(self):
"""
this returns a single string that should be fed into qdelaunay
"""
r = '2\n'
r += '%d\n' % len(self.points)
for p in self.points:
r += "%f %f\n" % (p[0], p[1])
return r
def __str__(self):
r = ''
assert( len(self.points) == len(self.q) )
@ -233,49 +174,7 @@ class grid(object):
r += "%s\n" % v
return r
class simple_rect_grid(grid):
def __init__(self, xres = 5, yres = 5):
xmin = -1.0
xmax = 1.0
xspan = xmax - xmin
xdel = xspan / float(xres - 1)
ymin = -1.0
ymay = 1.0
yspan = ymay - ymin
ydel = yspan / float(yres - 1)
points = []
q = []
for x in xrange(xres):
cur_x = xmin + (x * xdel)
for y in xrange(yres):
cur_y = ymin + (y * ydel)
points.append([cur_x, cur_y])
q.append(exact_func(cur_x, cur_y))
grid.__init__(self, points, q)
self.construct_connectivity()
class simple_random_grid(simple_rect_grid):
def __init__(self, num_points = 10):
points = []
q = []
r = np.random
for i in xrange(num_points):
cur_x = r.rand()
cur_y = r.rand()
points.append([cur_x, cur_y])
q.append(exact_func(cur_x, cur_y))
grid.__init__(self, points, q)
self.points = np.array(self.points)
self.q = np.array(self.q)
if __name__ == '__main__':

2
setup.py

@ -4,7 +4,7 @@ use_setuptools()
from setuptools import setup, find_packages
setup(
name = 'bakinterp',
name = 'interpolosion',
version = '0.01',
package_dir = {'':'lib'},
packages = find_packages('lib'),

47
test/baker.test.py

@ -10,7 +10,6 @@ import scipy.spatial
class TestSequenceFunctions(unittest.TestCase):
def setUp(self):
self.l = [[-1, 1], [-1, 0], [-1, 1], [0, -1], [0, 0], [0, 1], [1, -1], [1, 0], [1, 1]]
self.approx_fmt = "%0.6f"
self.all_points = [
[ 0, 0], # 0
[ 1, 0], # 1
@ -37,9 +36,9 @@ class TestSequenceFunctions(unittest.TestCase):
r = [[-1, -1], [0, 2], [1, -1]]
result = baker.get_phis(X, r)
result = [self.approx_fmt % i for i in result]
result = [round(i, 5) for i in result]
right_answer = [self.approx_fmt % i for i in [1/3.0, 1/3.0, 1/3.0]]
right_answer = [round(i, 5) for i in [1/3.0, 1/3.0, 1/3.0]]
for a,b in zip(result, right_answer):
self.assertEqual(a,b)
@ -78,13 +77,13 @@ class TestSequenceFunctions(unittest.TestCase):
self.q[size_of_simplex:size_of_simplex + extra_points])
answer = baker.run_baker(self.X, R, S)
a = self.approx_fmt % answer['a']
b = self.approx_fmt % answer['b']
c = self.approx_fmt % answer['c']
a = round(answer['a'], 5)
b = round(answer['b'], 5)
c = round(answer['c'], 5)
self.assertEqual(a, c)
self.assertEqual(c, self.approx_fmt % 0.00)
self.assertEqual(b, self.approx_fmt % (1/3.0))
self.assertEqual(c, round(0.00 , 5))
self.assertEqual(b, round(1/3.0, 5))
def testRunBaker_2(self):
size_of_simplex = 3
@ -98,12 +97,12 @@ class TestSequenceFunctions(unittest.TestCase):
answer = baker.run_baker(self.X, R, S)
a = self.approx_fmt % answer['a']
b = self.approx_fmt % answer['b']
c = self.approx_fmt % answer['c']
a = round(answer['a'], 5)
b = round(answer['b'], 5)
c = round(answer['c'], 5)
self.assertEqual(a, c)
self.assertEqual(c, self.approx_fmt % float(2/3.0))
self.assertEqual(c, round(float(2/3.0), 5))
def testRunBaker_3(self):
size_of_simplex = 3
@ -116,13 +115,13 @@ class TestSequenceFunctions(unittest.TestCase):
self.q[size_of_simplex:size_of_simplex + extra_points])
answer = baker.run_baker(self.X, R, S)
a = self.approx_fmt % answer['a']
b = self.approx_fmt % answer['b']
c = self.approx_fmt % answer['c']
a = round(answer['a'], 5)
b = round(answer['b'], 5)
c = round(answer['c'], 5)
self.assertEqual(a, self.approx_fmt % float(13/14.0))
self.assertEqual(b, self.approx_fmt % float(2 / 7.0))
self.assertEqual(c, self.approx_fmt % float(15/14.0))
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))
def testRunBaker_4(self):
size_of_simplex = 3
@ -135,13 +134,13 @@ class TestSequenceFunctions(unittest.TestCase):
self.q[size_of_simplex:size_of_simplex + extra_points])
answer = baker.run_baker(self.X, R, S)
a = self.approx_fmt % answer['a']
b = self.approx_fmt % answer['b']
c = self.approx_fmt % answer['c']
a = round(answer['a'], 5)
b = round(answer['b'], 5)
c = round(answer['c'], 5)
self.assertEqual(a, self.approx_fmt % float(48/53.0))
self.assertEqual(b, self.approx_fmt % float(15/53.0))
self.assertEqual(c, self.approx_fmt % float(54/53.0))
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))
if __name__ == '__main__':
suite = unittest.TestLoader().loadTestsFromTestCase(TestSequenceFunctions)

Loading…
Cancel
Save