def derive_exprs():
R = ReferenceFrame('N')
x, y = R[0], R[1]
w = x**2 * (1 - x)**2 / 10
c = gradient(w, R) * sympy.exp(-w)
f = divergence(c, R)
return dict(quantities=dict(w=w, c=c, f=f), R=R)
# alpha = symbols('a')
A1, A2 = symbols('A1 A2')
B1, B2 = symbols('B1 B2')
C2 = symbols('C2')
# Define interface offset (alpha)
alpha = 0.25 + A1 * t * sin(B1 * N[0]) + A2 * sin(B2 * N[0] + C2 * t)
# Define the solution equation (eta)
xi = (N[1] - alpha) / sqrt(2 * kappa)
eta_sol = (1 - tanh(xi)) / 2
eq_sol = simplify(
time_derivative(eta_sol, N) + 4 * eta_sol * (eta_sol - 1) *
(eta_sol - 0.5) - divergence(kappa * gradient(eta_sol, N), N))
# substitute coefficient values
parameters = ((kappa, params['kappa']), (A1, 0.0075), (B1, 8.0 * pi),
(A2, 0.03), (B2, 22.0 * pi), (C2, 0.0625 * pi))
subs = [sub.subs(parameters) for sub in (eq_sol, eta_sol)]
# generate FiPy lambda functions
from sympy.utilities.lambdify import lambdify
(eq_fp, eta_fp) = [
lambdify((N[0], N[1], t), sub, modules=fp.numerix) for sub in subs
]
pprint(sensor_functions)
# sensor_functions are functions which depend on absolute Sensor position.
# Let us find expressions for every Sensor values. We need to call this function
# providing sum of Sensor relative position plus associated Agents position
#print [sensor_function.subs({x: x, y: y}) if else for sensor_function in sensor_functions]
# Every P[i] is a vector of potentials that affect i-th matter,
# not including the effect that produces i-th matter itself
# Let us reduce this potential against weighted against
# force affect on atoms and number of atoms in specific matter
R = ReferenceFrame('R')
M = [(P[i]*E*Nu[i, :].T)[0].subs({x: R[0], y: R[1]}) for i in xrange(0, len(p))]
#pprint(M)
W = [gradient(M[i], R).to_matrix(R).subs({R[0]: x, R[1]: y})[:2] for i in xrange(len(p))]
# Natural laws transformation calculation
natural_field = diag(*(ones(1, len(p)) * ((Nu*G).multiply_elementwise(F))))
force_is_present = natural_field.applyfunc(
lambda exp: Piecewise((1.0, exp > 0.0),
(0.0, exp <= 0.0))
)
natural_influence = (Upsilon * Alpha * natural_field + S * Alpha)*force_is_present*ones(len(fs), 1)
pending_transformation_vector = Omicron.transpose()*natural_influence
#pprint(W, num_columns=1000)
get_eight_edges_pyramid_expression()]
# fs = [x**1,
# x**2,
# x**3,
# x**4,
# x**5,
# x**6]
F = Matrix(number_of_matters, len(fs), lambda i, j: fs[j].subs({x: x-ps[i][0], y: y-ps[i][1]}))
P = [Matrix(1, number_of_matters, lambda i, j: 0 if j == k else 1)*((Nu*G).multiply_elementwise(F)) for k in xrange(number_of_matters)]
R = ReferenceFrame('R')
M = [(P[i]*E*Nu[i, :].T)[0].subs({x: R[0], y: R[1]}) for i in xrange(0, number_of_matters)]
W = [gradient(M[i], R).to_matrix(R).subs({R[0]: x, R[1]: y})[:2] for i in xrange(number_of_matters)]
# Natural laws part
natural_field = diag(*(ones(1, number_of_matters) * ((Nu*G).multiply_elementwise(F))))
force_is_present = natural_field.applyfunc(
lambda exp: Piecewise((1.0, exp > 0.0),
(0.0, True))
)
natural_influence = (Upsilon * Alpha * natural_field + S * Alpha)*force_is_present*ones(len(fs), 1)
pending_transformation_vector = Omicron.transpose()*natural_influence
Nu_new = (Nu -
get_matrix_of_converting_atoms(Nu, ps, pending_transformation_vector) +
def test_Airy():
"""Compare finite depth Airy wave expression with results from analytical
expression"""
try:
import sympy as sp
from sympy.abc import t
from sympy.physics.vector import ReferenceFrame
from sympy.physics.vector import gradient, divergence
R = ReferenceFrame('R')
x, y, z = R[0], R[1], R[2]
Phi, k, h, g, rho = sp.symbols("Phi, k, h, g, rho")
omega = sp.sqrt(g * k * sp.tanh(k * h))
phi = g / omega * sp.cosh(k * (z + h)) / sp.cosh(
k * h) * sp.sin(k * x - omega * t)
u = gradient(phi, R)
p = -rho * Phi.diff(t)
for depth in np.linspace(100.0, 10.0, 2):
for omega in np.linspace(0.5, 4.0, 2):
dp = DiffractionProblem(dummy,
free_surface=0.0,
sea_bottom=-depth,
omega=omega)
for t_val, x_val, y_val, z_val in product(
np.linspace(0.0, 1.0, 2), np.linspace(-10, 10, 3),
np.linspace(-10, 10, 3), np.linspace(-10, 0, 3)):
parameters = {
t: t_val,
x: x_val,
y: y_val,
z: z_val,
omega: dp.omega,
k: dp.wavenumber,
h: dp.depth,
g: dp.g,
rho: dp.rho
}
phi_num = dp.Airy_wave_potential(
np.array((x_val, y_val, z_val)))
assert np.isclose(float(phi.subs(parameters)),
np.real(phi_num *
np.exp(-1j * dp.omega * t_val)),
rtol=1e-3)
u_num = dp.Airy_wave_velocity(
np.array((x_val, y_val, z_val)))
assert np.isclose(float(u.dot(R.x).subs(parameters)),
np.real(u_num[0] *
np.exp(-1j * dp.omega * t_val)),
rtol=1e-3)
assert np.isclose(float(u.dot(R.y).subs(parameters)),
np.real(u_num[1] *
np.exp(-1j * dp.omega * t_val)),
rtol=1e-3)
assert np.isclose(float(u.dot(R.z).subs(parameters)),
np.real(u_num[2] *
np.exp(-1j * dp.omega * t_val)),
rtol=1e-3)
except ImportError:
print("Not tested with sympy.")
x = R[0]
y = R[1]
a=-0.5
b=1.5
visc=1e-1
lambda_=(1/(2*visc)-sqrt(1/(4*visc**2)+4*pi**2))
print(" visc=%f" % visc)
u=[0,0]
u[0]=1-exp(lambda_*x)*cos(2*pi*y)
u[1]=lambda_/(2*pi)*exp(lambda_*x)*sin(2*pi*y)
p=(exp(3*lambda_)-exp(-lambda_))/(8*lambda_)-exp(2*lambda_*x)/2
p=p - integrate(p, (x,a,b))
grad_p = gradient(p, R).to_matrix(R)
f0 = -divergence(visc*gradient(u[0], R), R) + grad_p[0]
f1 = -divergence(visc*gradient(u[1], R), R) + grad_p[1]
f2 = divergence(u[0]*R.x + u[1]*R.y, R)
print("\n * RHS:")
print(ccode(f0, assign_to = "values[0]"))
print(ccode(f1, assign_to = "values[1]"))
print(ccode(f2, assign_to = "values[2]"))
print("\n * ExactSolution:")
print(ccode(u[0], assign_to = "values[0]"))
print(ccode(u[1], assign_to = "values[1]"))
print(ccode(p, assign_to = "values[2]"))
def compile(self):
"""
This method generates callable objects, that
:return:
"""
number_of_matters = len(self.matters)
number_of_atoms = len(self.atoms)
number_of_forces = len(self.forces)
number_of_sensors = len(self.sensors)
number_of_agents = len(self.agents)
ps = [[Symbol('p_x_{i}'.format(i=i)), Symbol('p_y_{i}'.format(i=i))] for i in xrange(number_of_matters)]
fs = [force.function() for force in self.forces]
F = Matrix(number_of_matters,
number_of_forces,
lambda i, j: fs[j].subs({x: x-ps[i][0], y: y-ps[i][1]}))
# G stands for "generated functions"
G = Matrix(len(self.atoms),
len(self.forces),
lambda i, j: 1 if self.forces[j] in self.atoms[i].produced_forces else 0)
# E stands for "effect"
E = Matrix(len(self.forces),
len(self.atoms),
lambda i, j: 1 if self.atoms[j] in self.forces[i].atoms_to_produce_effect_on else 0)
# Accelerator force
Alpha = Matrix(len(self.natural_laws),
len(self.forces),
lambda i, j: 1 if self.forces[j] is self.natural_laws[i].accelerator else 0)
# Multiplicative component of natural law
Upsilon = diag(*[natural_law.multiplicative_component for natural_law in self.natural_laws])
# Additive component of natural law
S = diag(*[natural_law.additive_component for natural_law in self.natural_laws])
# Omicron stands for origin
Omicron = Matrix(len(self.natural_laws),
len(self.atoms),
lambda i, j: 1 if self.atoms[j] is self.natural_laws[i].atom_in else 0)
# D stands for destination
D = Matrix(len(self.natural_laws),
len(self.atoms),
lambda i, j: 1 if self.atoms[j] is self.natural_laws[i].atom_out else 0)
Nu = Matrix(number_of_matters,
number_of_atoms,
lambda i, j: Symbol("nu_{i}_{j}".format(i=i, j=j)))
# T stands for target [of Sensor]
T = Matrix(number_of_sensors,
number_of_forces,
lambda i, j: 1 if self.forces[j] is self.sensors[i].perceived_force else 0)
# TODO: check weather this expression is duplication
ps = [[Symbol('p_x_{i}'.format(i=i)), Symbol('p_y_{i}'.format(i=i))] for i in xrange(number_of_matters)]
P = [Matrix(1, number_of_matters, lambda i, j: 0 if j == k else 1)*((Nu*G).multiply_elementwise(F)) for k in xrange(number_of_matters)]
R = ReferenceFrame('R')
M = [(P[i]*E*Nu[i, :].T)[0].subs({x: R[0], y: R[1]}) for i in xrange(0, number_of_matters)]
W = [gradient(M[i], R).to_matrix(R).subs({R[0]: x, R[1]: y})[:2] for i in xrange(number_of_matters)]
# Natural laws part
natural_field = diag(*(ones(1, number_of_matters) * ((Nu*G).multiply_elementwise(F))))
force_is_present = natural_field.applyfunc(
lambda exp: Piecewise((1.0, exp > 0.0),
(0.0, True))
)
natural_influence = (Upsilon * Alpha * natural_field + S * Alpha)*force_is_present*ones(len(fs), 1)
pending_transformation_vector = Omicron.transpose()*natural_influence
Nu_new = (Nu -
get_matrix_of_converting_atoms(Nu, ps, pending_transformation_vector) +
get_matrix_of_converted_atoms(Nu, ps, pending_transformation_vector, natural_influence, Omicron, D))
delta_t = Symbol('Delta_t')
inputs = map(lambda s: Symbol(s),
list(itertools.chain(["Delta_t"],
map(lambda s: str(s), itertools.chain(*ps)),
["nu_{i}_{j}".format(i=i, j=j)
for i in xrange(number_of_matters) for j in xrange(number_of_atoms)]
)))
self.new_position_generators = list()
position_functions = list()
for i in xrange(number_of_matters):
(x_v, y_v) = tuple(ps[i])
(dx, dy) = (x_v + W[i][0].subs({x: x_v, y: y_v})*delta_t, y_v + W[i][1].subs({x: x_v, y: y_v})*delta_t)
cuda_code_dx = position_device_function_template.format(component="x", idx=i, expression=self.convert_position_code_to_cuda(ccode(dx)))
cuda_code_dy = position_device_function_template.format(component="y", idx=i, expression=self.convert_position_code_to_cuda(ccode(dy)))
position_functions.append(cuda_code_dx)
position_functions.append(cuda_code_dy)
dx_op = SymPyCCode(inputs, dx)
dy_op = SymPyCCode(inputs, dy)
input_scalars = [theano.tensor.dscalar(str(inp)) for inp in inputs]
dx_dy_t = theano.function(input_scalars, [dx_op(*input_scalars), dy_op(*input_scalars)])
self.new_position_generators.append(dx_dy_t)
function_list_x = ", ".join(["""p_{component}_func_{idx}""".format(component="x", idx=i) for i in xrange(number_of_matters)])
function_list_x_cuda_code = position_transition_functions_template.format(component="x", functions_list=function_list_x)
function_list_y = ", ".join(["""p_{component}_func_{idx}""".format(component="y", idx=i) for i in xrange(number_of_matters)])
function_list_y_cuda_code = position_transition_functions_template.format(component="y", functions_list=function_list_y)
# Natural law theano optimization
self.new_quantities_generators = list()
atoms_quantities_functions = list()
for i in xrange(number_of_matters):
for j in xrange(number_of_atoms):
cuda_code_nu = atom_quantities_device_function_template.format(
idx=i*number_of_atoms+j,
expression=self.convert_atoms_quantities_code_to_cuda(ccode(Nu_new[i, j])))
atoms_quantities_functions.append(cuda_code_nu)
nu_op = SymPyCCode(inputs, Nu_new[i, j])
input_scalars = [theano.tensor.dscalar(str(inp)) for inp in inputs]
nu_t = theano.function(input_scalars, [nu_op(*input_scalars), ])
self.new_quantities_generators.append(nu_t)
atoms_quantities_functions_list = ", ".join(["""nu_func_{idx}""".format(idx=i) for i in xrange(number_of_matters*number_of_atoms)])
atoms_quantities_functions_list_cuda_code = atoms_quantities_functions_template.format(functions_list=atoms_quantities_functions_list)
positions_initialization_cuda_code = list()
for p_x_i, p_x in enumerate(self.matters_positions[0::2]):
positions_initialization_cuda_code.append("p_x[{idx}] = {value};".format(idx=p_x_i, value=p_x))
for p_y_i, p_y in enumerate(self.matters_positions[1::2]):
positions_initialization_cuda_code.append("p_y[{idx}] = {value};".format(idx=p_y_i, value=p_y))
atoms_quantities_initialization_cuda_code = list()
for i in xrange(len(self.matters)):
for j in xrange(len(self.atoms)):
atoms_quantities_initialization_cuda_code.append("nu[{matter_idx}*NUMBER_OF_ATOMS + {atom_idx}] = {value};".format(matter_idx=i,
atom_idx=j,
value=self.atoms_quantities[(len(self.atoms)*i + j)]))
return {"positions_functions": "\n".join(position_functions),
"positions_functions_list": "\n".join([function_list_x_cuda_code, function_list_y_cuda_code]),
"atoms_quantities_functions": "\n".join(atoms_quantities_functions),
"atoms_quantities_functions_list": atoms_quantities_functions_list_cuda_code,
"positions_initialization": "\n".join(positions_initialization_cuda_code),
"atoms_quantities_initialization": "\n".join(atoms_quantities_initialization_cuda_code)}
from sympy.physics.vector import gradient, ReferenceFrame
from sympy.abc import x, y
R = ReferenceFrame("R")
rect = (
BITMAP_BOUNDING_RECT_BASE_X_DEFAULT,
BITMAP_BOUNDING_RECT_BASE_Y_DEFAULT,
BITMAP_BOUNDING_RECT_EXTENT_X_DEFAULT,
BITMAP_BOUNDING_RECT_EXTENT_Y_DEFAULT,
)
image_path = "/Users/aloschil/workspace/game_engine/snippets/bitmap_force_input.jpg"
print ">>>>>>>>>> First call"
f = build_optimized_function(image_path, rect)
print f
w = gradient(10.0 * f(x, y).subs({x: R[0], y: R[1]}), R).to_matrix(R).subs({R[0]: x, R[1]: y})[:2]
(x_v, y_v) = (10.0, 10.0)
print w[0].subs({x: x_v, y: y_v})
print w[1].subs({x: x_v, y: y_v})
print "<<<<<<<<<First call ended \n\n\n"
sleep(50)
print ">>>>>>>> A call after 50 seconds"
print build_optimized_function(image_path, rect)
f = build_optimized_function(image_path, rect)
print f
w = gradient(10.0 * f(x, y).subs({x: R[0], y: R[1]}), R).to_matrix(R).subs({R[0]: x, R[1]: y})[:2]
(x_v, y_v) = (10.0, 10.0)
print w[0].subs({x: x_v, y: y_v})
print w[1].subs({x: x_v, y: y_v})
print "<<<<<<<< end of the call after 20 seconds\n\n\n"
R = ReferenceFrame('R')
x = R[0]
y = R[1]
visc = Symbol("nu")
# visc=1e-1;
# print(" visc=%f" % visc)
u = [0, 0]
u[0] = pi * sin(pi * x) * sin(pi * x) * sin(2 * pi * y)
u[1] = -pi * sin(2 * pi * x) * sin(pi * y) * sin(pi * y)
p = cos(pi * x) * sin(pi * y)
# p=p - integrate(p, (x,a,b));
grad_p = gradient(p, R).to_matrix(R)
f0 = simplify(-divergence(visc * gradient(u[0], R), R)) + grad_p[0]
f1 = simplify(-divergence(visc * gradient(u[1], R), R)) + grad_p[1]
f2 = simplify(divergence(u[0] * R.x + u[1] * R.y, R))
print("f:")
print(f0)
print(f1)
print(f2)
print("\n * RHS:")
print(ccode(f0, assign_to="values[0]"))
print(ccode(f1, assign_to="values[1]"))
print(ccode(f2, assign_to="values[2]"))
print("\n * ExactSolution:")
y = R[1]
a = -0.5
b = 1.5
visc = 1e-1
lambda_ = (1 / (2 * visc) - sqrt(1 / (4 * visc**2) + 4 * pi**2))
print(" visc=%f" % visc)
u = [0, 0]
u[0] = 1 - exp(lambda_ * x) * cos(2 * pi * y)
u[1] = lambda_ / (2 * pi) * exp(lambda_ * x) * sin(2 * pi * y)
p = (exp(3 * lambda_) - exp(-lambda_)) / (8 * lambda_) - exp(
2 * lambda_ * x) / 2
p = p - integrate(p, (x, a, b))
grad_p = gradient(p, R).to_matrix(R)
f0 = -divergence(visc * gradient(u[0], R), R) + grad_p[0]
f1 = -divergence(visc * gradient(u[1], R), R) + grad_p[1]
f2 = divergence(u[0] * R.x + u[1] * R.y, R)
print("\n * RHS:")
print(ccode(f0, assign_to="values[0]"))
print(ccode(f1, assign_to="values[1]"))
print(ccode(f2, assign_to="values[2]"))
print("\n * ExactSolution:")
print(ccode(u[0], assign_to="values[0]"))
print(ccode(u[1], assign_to="values[1]"))
print(ccode(p, assign_to="values[2]"))
print("")
du = 0. * R.x
for x in (R[0], R[1], R[2]):
for vect in (R.x, R.y, R.z):
du += diff(u.dot(vect), x, x) * vect
D_visc = 0.0
D_therm = 0.0
D_comp = 0.0
B_therm = Symbol("B_therm")
B_comp = Symbol("B_comp")
S_therm = Symbol("S_therm")
S_comp = Symbol("S_comp")
# Construct the equations
continuity = divergence(u, R)
momentum = I * ang * u + gradient(p, R) - B_therm * temp * R.z + B_comp * chem * R.z - D_visc * du
temperature = I * ang * temp + S_therm * u.dot(R.z) - D_therm * divergence(gradient(temp, R), R)
composition = I * ang * chem + S_comp * u.dot(R.z) - D_comp * divergence(gradient(chem, R), R)
# Solve the equations
# print(solve(temperature, "T"))
subT = solve(temperature, "T")[0]
# print(solve(composition, "C"))
subC = solve(composition, "C")[0]
# print(solve(momentum.dot(R.z).subs(Temp, subT).subs(Chem, subC), "P"))
subP = solve(momentum.dot(R.z).subs(Temp, subT).subs(Chem, subC), "P")[0]
# print(solve(momentum.dot(R.x).subs(P, subP), "Ux"))
subUx = solve(momentum.dot(R.x).subs(P, subP), "Ux")[0]
# print(solve(momentum.dot(R.y).subs(P, subP), "Uy"))
