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 10 years ago
parent
commit
b33159f8a9
8 changed files with 152 additions and 155 deletions
  1. +0
    -1
      .setup
  2. +10
    -12
      bin/driver.py
  3. +2
    -2
      bin/grid_regular.py
  4. +103
    -10
      lib/baker/baker.py
  5. +9
    -0
      lib/baker/tools.py
  6. +4
    -105
      lib/grid/grid.py
  7. +1
    -1
      setup.py
  8. +23
    -24
      test/baker.test.py

+ 0
- 1
.setup View File

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

+ 10
- 12
bin/driver.py View File

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



+ 2
- 2
bin/grid_regular.py View File

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



+ 103
- 10
lib/baker/baker.py View File

@@ -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
- 0
lib/baker/tools.py View File

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

+ 4
- 105
lib/grid/grid.py View File

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


+ 1
- 1
setup.py View File

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


+ 23
- 24
test/baker.test.py View File

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