def test_euler(self):
graph = Graph()
graph.add_nodes("A,B,C")
graph.add_link("A", "B")
graph.add_link("A", "C")
graph.add_link("B", "C")
node_a = graph.node("A")
euler = Euler(graph, node_a)
path = []
success = euler.euler(node_a, node_a, path)
self.assertTrue(success)
node_b = graph.node("B")
euler = Euler(graph, node_a)
path = []
success = euler.euler(node_a, node_b, path)
self.assertFalse(success)
graph.add_nodes("D,E")
graph.add_link("B", "D")
graph.add_link("B", "E")
graph.add_link("E", "D")
euler = Euler(graph, node_b)
path = []
success = euler.euler(node_b, node_b, path)
self.assertTrue(success)
def test_remove_link(self):
graph = Graph()
node_a = Node("A")
euler = Euler(graph, node_a)
node_b = Node("B")
link = Link(node_a, node_b)
euler.unused_links.add(link)
euler.add_link(link)
self.assertEqual(len(euler.unused_links), 0)
self.assertEqual(euler.link_count[link], 1)
euler.remove_link(link)
self.assertEqual(len(euler.unused_links), 1)
self.assertEqual(euler.link_count[link], 0)
euler.add_link(link)
euler.add_link(link)
self.assertEqual(len(euler.unused_links), 0)
self.assertEqual(euler.link_count[link], 2)
euler.remove_link(link)
self.assertEqual(len(euler.unused_links), 0)
self.assertEqual(euler.link_count[link], 1)
euler.remove_link(link)
self.assertEqual(len(euler.unused_links), 1)
self.assertTrue(link in euler.unused_links)
self.assertEqual(euler.link_count[link], 0)
def test_Euler(data):
initial_x = data[0]
initial_y = data[1]
intervals = data[2]
final_x = data[3]
exp = data[4]
exp = exp.replace('m', '*')
exp = exp.replace('p', '**')
exp = exp[1:len(exp)]
# print(str(exp))
f = sympy.sympify(exp)
assume(final_x > initial_x)
assume(intervals > 0)
y1 = Euler(exp, initial_x, initial_y, final_x, intervals)
t = []
last = initial_x
step = (final_x - initial_x) / intervals
# print(step)
for i in range(intervals):
last += step
t.append(last)
x = sympy.symbols('x')
y = sympy.symbols('y')
fx = lambdify([x, y], f)
# print(f)
y2 = odeint(fx, initial_y, np.asarray(t))
# print(len(result))
# print(exp,initial_x,initial_y,final_x,intervals)
# print(len(y1),len(y2))
for i in range(len(y2)):
note("numpy sol %r" % y2[i][0])
note("app solution %r" % y1[i])
assert y2[i][0] == y1[i]
def test_init(self):
graph = Graph()
graph.add_nodes("A,B,C")
graph.add_link("A", "B")
graph.add_link("A", "C")
graph.add_link("B", "C")
node = graph.node("A")
euler = Euler(graph, node)
self.assertEqual(euler.graph, graph)
self.assertIsNotNone(euler.unused_links)
self.assertEqual(len(euler.unused_links), 3)
self.assertIsNotNone(euler.link_count)
self.assertEqual(len(euler.link_count), 0)
def decodeValue(jsonData):
"""Returns a constructed math value based on the provided json data.
Args:
jsondata (dict): The JSON data to use to decode into a Math value.
Returns:
object: The constructed math value
"""
if type(jsonData) is not dict:
return jsonData
if '__mathObjectClass__' not in jsonData:
raise Exception("Invalid JSON data for constructing value:" +
str(jsonData))
if jsonData['__mathObjectClass__'] == 'Vec2':
val = Vec2()
val.jsonDecode(jsonData, decodeValue)
elif jsonData['__mathObjectClass__'] == 'Vec3':
val = Vec3()
val.jsonDecode(jsonData, decodeValue)
elif jsonData['__mathObjectClass__'] == 'Vec4':
val = Vec4()
val.jsonDecode(jsonData, decodeValue)
elif jsonData['__mathObjectClass__'] == 'Euler':
val = Euler()
val.jsonDecode(jsonData, decodeValue)
elif jsonData['__mathObjectClass__'] == 'Quat':
val = Quat()
val.jsonDecode(jsonData, decodeValue)
elif jsonData['__mathObjectClass__'] == 'Xfo':
val = Xfo()
val.jsonDecode(jsonData, decodeValue)
elif jsonData['__mathObjectClass__'] == 'Mat33':
val = Mat33()
val.jsonDecode(jsonData, decodeValue)
elif jsonData['__mathObjectClass__'] == 'Mat44':
val = Mat44()
val.jsonDecode(jsonData, decodeValue)
else:
raise Exception("Unsupported Math type:" +
jsonData['__mathObjectClass__'])
return val
def __init__(self, parent=None):
super(GUI, self).__init__(parent)
self.euler = Euler(1.0, 1.0, 9.5, 100)
self.exact = Exact(1.0, 1.0, 9.5, 100)
self.improved_euler = Improved_euler(1.0, 1.0, 9.5, 100)
self.rungekutta = RungeKutta(1.0, 1.0, 9.5, 100)
self.createTopGroupBox()
self.createSelectInitialBox()
self.createMethodBox()
self.createTabBox()
mainLayout = QGridLayout()
mainLayout.addWidget(self.topGroupBox, 0, 0)
mainLayout.addWidget(self.selectInitialBox, 1, 0)
mainLayout.addWidget(self.methodBox, 2, 0)
mainLayout.addWidget(self.bottomTabWidget, 3, 0)
self.setLayout(mainLayout)
def __init__(self, param, grid):
self.list_param = [
'modelname', 'tend', 'fixed_dt', 'dt', 'cfl', 'plot_var', 'cax',
'colorscheme', 'plot_interactive', 'fixed_dt', 'dtmax',
'freq_save', 'freq_plot'
]
param.copy(self, self.list_param)
self.list_grid = ['dx', 'nh', 'msk']
grid.copy(self, self.list_grid)
if param.modelname == 'euler':
from euler import Euler
self.model = Euler(param, grid)
if param.modelname == 'advection':
from advection import Advection
self.model = Advection(param, grid)
if param.modelname == 'boussinesq':
from boussinesq import Boussinesq
self.model = Boussinesq(param, grid)
if param.modelname == 'quasigeostrophic':
from quasigeostrophic import QG
self.model = QG(param, grid)
self.diag = Diag(param, grid)
self.plotting = Plotting(param)
# here's a shortcut to the model state
self.state = self.model.var.state
self.t = 0.
self.kt = 0
self.output = Output(param, grid, self.diag)
def setUp(self):
self.euler = Euler("y'=y*cos(x),\ny(0)=1\n\n")
if opc == "1":
a = Area()
while True:
print("\n1. Area cuadrado")
print("2. Area triangulo")
print("3. Area circulo")
op = input("Elige una opcion: ")
if op == "1":
a.areaCuadrado()
elif op == "2":
a.areaTriangulo()
elif op == "3":
a.areaCirculo()
elif op == "0":
break
elif opc == "2":
print("\n")
z = Zodiaco()
z.signo()
elif opc == "3":
e = Euler()
print("\n")
limite = int(input("Limite: "))
n = e.numeroe(limite)
print("e: ", n)
else:
break
from euler import Euler
geom = rotate(loadtxt('../data/n0012c.dat'), 30*pi/180)
nE = 1000
dt = 0.001
Mach = 0.3
HiRes = 1.
if not os.path.exists('fig'): os.mkdir('fig')
for iAdapt in range(4):
print 'Adapt cycle {0}'.format(iAdapt)
if iAdapt == 0:
v, t, b = initMesh(geom, nE)
solver = Euler(v, t, b, Mach, HiRes)
solver.integrate(1E-8, solver.freeStream())
else:
xt0, W0 = solver.mesh.xt(), solver.soln
v, t, b = adaptMesh(geom, v, t, b, nE, metric)
solver = Euler(v, t, b, Mach, HiRes)
W0 = griddata(xt0, W0, solver.mesh.xt(), method='nearest')
solver.integrate(1E-8, W0)
metric = zeros([v.shape[0], 2, 2]) # metric for next adaptation
for T in arange(1,21) * dt:
solver.integrate(T)
metric += solver.metric()
clf()
solver.mesh.plotTriScalar(solver.soln[:,0])
def __init__(self, param, grid):
# let's first check that no param is obviously incorrect
param.checkall()
# copy the launch script into 'expname.py' to allow
# for experiment reproducibility
launchscript = sys.argv[0]
param.datadir = param.datadir.replace('~', os.getenv("HOME"))
param.expdir = '%s/%s' % (param.datadir, param.expname)
if param.myrank == 0:
if os.path.isdir(param.expdir):
pass
else:
os.makedirs(param.expdir)
savedscript = '%s/%s.py' % (param.expdir, param.expname)
outfile = '%s/output.txt' % param.expdir
if os.path.exists(outfile):
print(
'Warning: this experiment has already been ran, output.txt already exists'
)
print('dummy.txt will be used instead')
outfile = '%s/dummy.txt' % param.expdir
sys.stdout = Logger(outfile)
if os.path.exists(savedscript):
print('Warning: the python script already exists in %s' %
param.expdir)
print('the script won' 't be copied')
pass
else:
self.savedscript = savedscript
call(['cp', launchscript, savedscript])
self.list_param = [
'modelname', 'tend', 'adaptable_dt', 'dt', 'cfl', 'dtmax',
'myrank', 'nprint', 'exacthistime', 'rescaledtime', 'noslip',
'geometry', 'diag_fluxes', 'print_param', 'enforce_momentum',
'forcing', 'decay', 'plotting_module', 'freq_save', 'freq_plot',
'plot_interactive', 'nbproc', 'isisland', 'npx', 'npy', 'nx', 'ny'
]
param.copy(self, self.list_param)
self.dt0 = self.dt
grid.finalize_msk()
# print('momentum=',self.enforce_momentum)
self.list_grid = ['dx', 'dy', 'nh', 'msk', 'xr0', 'yr0', 'x2', 'y2']
grid.copy(self, self.list_grid)
if param.modelname == 'euler':
if self.geometry not in ['closed', 'disc']:
self.enforce_momentum = False
from euler import Euler
self.model = Euler(param, grid)
else:
# not yet implemented in other models
self.enforce_momentum = False
if param.modelname == 'advection':
from advection import Advection
self.model = Advection(param, grid)
if param.modelname == 'boussinesq':
from boussinesq import Boussinesq
self.model = Boussinesq(param, grid)
if param.modelname == 'boussinesqTS':
from boussinesqTS import BoussinesqTS
self.model = BoussinesqTS(param, grid)
if param.modelname == 'quasigeostrophic':
from quasigeostrophic import QG
self.model = QG(param, grid)
if param.modelname == 'thermalwind':
from thermalwind import Thermalwind
self.model = Thermalwind(param, grid)
if self.modelname == 'quasigeostrophic':
self.enstrophyname = 'pv2'
else:
self.enstrophyname = 'enstrophy'
if self.isisland:
grid.island.finalize(self.model.ope.mskp)
self.model.ope.rhsp = grid.island.rhsp
self.model.ope.psi = grid.island.psi
# self.diag = Diag(param,grid)
if self.diag_fluxes:
self.flx = Flx.Fluxes(param, grid, self.model.ope)
flxlist = self.flx.fullflx_list
else:
flxlist = None
if self.plot_interactive:
try:
p = import_module(self.plotting_module)
# print(self.plotting_module)
except ImportError:
print('problem with the interactive plotting')
print('this might be due to a backend issue')
print('try to rerun the code with')
print('param.plot_interactive = False')
exit(0)
self.plotting = p.Plotting(param, grid, self.model.var,
self.model.diags)
self.tracer_list = param.tracer_list
# here's a shortcut to the model state
self.state = self.model.var.state
self.t = 0.
self.kt = 0
self.output = Output(param, grid, self.model.diags, flxlist=flxlist)
self.print_config(param, start=True)
def setUp(self):
self.e = Euler()
self.problem1 = 'If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000.'
self.problem2 = '''Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be: 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ... By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.'''
def update(self):
"""時間発展(タイムオーダーは成長よりも短くすること)
各点にかかる力は，それぞれに付いているバネから受ける力の合力。
Runge-Kutta法を用いて運動方程式を解く。
この内部でglow関数を呼ぶ
--- Arguments ---
point (class): 参照するPointクラスを指定する
h (float): シミュレーションの時間発展の刻み
t_max (float): シミュレーションを終了する時間
"""
# 初期条件
X = np.array([
self.point.position_x, self.point.position_y, self.point.vel_x,
self.point.vel_y
])
# X = [[x0, x1, ... , xN-1],
# [y1, y2, ... , yN-1],
# [x'0, x'1, ... , x'N-1],
# [y'1, y'2, ..., y'N-1]]
# solver = RK4(self.force) # Runge-Kutta method
# solver = RK4(self.force_with_more_viscosity) # Runge-Kutta method
# solver = Euler(self.force) # Euler method
solver = Euler(self.force_with_more_viscosity) # Euler method
t_count, frame = 0, 0
while self.t < self.t_max:
if not self.pause:
X = solver.solve(X, self.t, self.h)
# update values
self.point.position_x, self.point.position_y = X[0], X[1]
self.point.vel_x, self.point.vel_y = X[2], X[3]
# 各バネの自然長を増加させる & バネ定数を変化させる
self.point.grow(self.grow_func, self.grow_func_k)
# 各点間の距離が基準値を超えていたら，間に新たな点を追加する
X = self.point.divide_if_extended(X)
# self avoiding
if self.self_avoiding:
self.update_position_self_avoiding()
# 一定の間隔で描画を行う
if self.t > self.h * 12 * frame: # TODO: 要検討
log.info(self.t)
log.info("N: " + str(self.point.N))
log.info("x: " + str(self.point.position_x))
log.info("y: " + str(self.point.position_y))
log.info("d: " + str(
self.point.get_distances(self.point.position_x,
self.point.position_y)))
log.info("nl: " + str(self.point.natural_length))
log.info("K: " + str(self.point.K))
if self.point.is_open:
yield [self.point.position_x, self.point.position_y]
else:
yield [
np.append(self.point.position_x,
self.point.position_x[0]),
np.append(self.point.position_y,
self.point.position_y[0])
]
frame += 1
t_count += 1
self.t = self.h * t_count
else:
time.sleep(0.1)
if self.point.is_open:
yield [self.point.position_x, self.point.position_y]
else:
yield [
np.append(self.point.position_x,
self.point.position_x[0]),
np.append(self.point.position_y,
self.point.position_y[0])
]
print "Done!"
from euler import Euler
from math import pi
if __name__ == "__main__":
equation = input("enter first order differential equation: ")
curve = input("curve: ")
x0 = float(input("x0: "))
y0 = float(input("y0: "))
if curve == "":
e = Euler(equation, x0, y0)
else:
e = Euler(equation, x0, y0, curve)
while True:
x_final = eval(input("find value at: "))
step_size = float(input("step_size: "))
e.compare_errors(x_final, step_size)
def update(self):
"""時間発展(タイムオーダーは成長よりも短くすること)
各点にかかる力は，それぞれに付いているバネから受ける力の合力。
Runge-Kutta法を用いて運動方程式を解く。
この内部でglow関数を呼ぶ
--- Arguments ---
point (class): 参照するPointクラスを指定する
h (float): シミュレーションの時間発展の刻み
t_max (float): シミュレーションを終了する時間
"""
# 初期条件
X = np.array([self.point.position_x, self.point.position_y,
self.point.vel_x, self.point.vel_y
])
# X = [[x0, x1, ... , xN-1],
# [y1, y2, ... , yN-1],
# [x'0, x'1, ... , x'N-1],
# [y'1, y'2, ..., y'N-1]]
# solver = RK4(self.force) # Runge-Kutta method
# solver = RK4(self.force_with_more_viscosity) # Runge-Kutta method
# solver = Euler(self.force) # Euler method
solver = Euler(self.force_with_more_viscosity) # Euler method
count_grow, frame = 1, 0
grow_interval = 1000
plot_interval = 8
while self.t < self.t_max:
print self.t
if not self.pause:
print "solver"
X = solver.solve(X, self.t, self.h)
# update values
self.point.position_x, self.point.position_y = X[0], X[1]
self.point.vel_x, self.point.vel_y = X[2], X[3]
# ある時間間隔で新しく線素を追加する
print self.h * grow_interval * count_grow
if self.t > self.h * grow_interval * count_grow:
print "add point"
X = self.point.add()
count_grow += 1
# self avoiding
if self.self_avoiding:
self.update_position_self_avoiding()
# 一定の間隔で描画を行う
if self.t > self.h * plot_interval * frame:
log.info(self.t)
log.info("N: " + str(self.point.N))
log.info("x: " + str(self.point.position_x))
log.info("y: " + str(self.point.position_y))
log.info("d: " + str(self.point.distances(
self.point.position_x, self.point.position_y)))
log.info("nl: " + str(self.point.natural_length))
log.info("K: " + str(self.point.K))
if self.point.is_open:
yield [self.point.position_x, self.point.position_y]
else:
yield [np.append(self.point.position_x,
self.point.position_x[0]),
np.append(self.point.position_y,
self.point.position_y[0])]
frame += 1
self.t = self.t + self.h
else:
time.sleep(0.1)
if self.point.is_open:
yield [self.point.position_x, self.point.position_y]
else:
yield [np.append(self.point.position_x,
self.point.position_x[0]),
np.append(self.point.position_y,
self.point.position_y[0])]
print "Done!"
def __init__(self, param, grid):
self.list_param = [
'modelname', 'tend', 'adaptable_dt', 'dt', 'cfl', 'dtmax',
'myrank', 'nprint', 'rescaledtime', 'noslip', 'geometry',
'enforce_momentum', 'forcing', 'plotting_module', 'freq_save',
'freq_plot', 'plot_interactive', 'nbproc', 'isisland'
]
param.copy(self, self.list_param)
grid.finalize_msk()
#print('momentum=',self.enforce_momentum)
self.list_grid = ['dx', 'nh', 'msk', 'xr0', 'yr0', 'x2', 'y2']
grid.copy(self, self.list_grid)
if param.modelname == 'euler':
if not (self.geometry in ['square', 'disc']):
self.enforce_momentum = False
from euler import Euler
self.model = Euler(param, grid)
else:
# not yet implemented in other models
self.enforce_momentum = False
if param.modelname == 'advection':
from advection import Advection
self.model = Advection(param, grid)
if param.modelname == 'boussinesq':
from boussinesq import Boussinesq
self.model = Boussinesq(param, grid)
if param.modelname == 'quasigeostrophic':
from quasigeostrophic import QG
self.model = QG(param, grid)
if self.isisland:
grid.island.finalize(self.model.ope.mskp)
self.model.ope.rhsp = grid.island.rhsp
self.model.ope.psi = grid.island.psi
# self.diag = Diag(param,grid)
if self.plot_interactive:
try:
p = import_module(self.plotting_module)
except:
print('module %s for plotting cannot be found' %
self.plotting_module)
print('make sure file **%s.py** exists' % self.plotting_module)
exit(0)
self.plotting = p.Plotting(param, grid, self.model.var,
self.model.diags)
# here's a shortcut to the model state
self.state = self.model.var.state
self.t = 0.
self.kt = 0
self.output = Output(param, grid, self.model.diags)
