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.
This commit is contained in:
Stephen Mardson McQuay
parent
a2d7b3f063
commit
b33159f8a9
@ -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()
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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]]
|
||||
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.333, 0.333, 0.333]
|
||||
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,9 +108,7 @@ def run_baker(X, R, S):
|
||||
X = [0,0]
|
||||
|
||||
R = Simplex
|
||||
|
||||
S = extra points
|
||||
|
||||
"""
|
||||
|
||||
# calculate values only for the triangle
|
||||
@ -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
|
||||
|
||||
@ -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
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
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'),
|
||||
|
||||
@ -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…
Reference in New Issue
Block a user