def __init__(self, receiver):
self.root = Tk()
self.m = Tube(self.root)
self.m.receiver = receiver
self.root.title("Play Youtube URL")
self.root.protocol("WM_DELETE_WINDOW", self.on_exit)
self.root.mainloop()
def test_tube_dsdx_2():
xs = [0, 2, 4, 6]
ds = [1, 2, 4, 2]
t = Tube(xs, ds)
for i in range(33):
x1 = 0 + random.random() * 2
x2 = 0 + random.random() * 2
x1, x2 = min(x1, x2), max(x1, x2)
assert t.get_dsdx(np.array([x1, x2])) == approx([
(pi * 2**2 / 4 - pi * 1**2 / 4) / 2
])
for i in range(33):
x1 = 2 + random.random() * 2
x2 = 2 + random.random() * 2
x1, x2 = min(x1, x2), max(x1, x2)
assert t.get_dsdx(np.array([x1, x2])) == approx([
(pi * 4**2 / 4 - pi * 2**2 / 4) / 2
])
for i in range(33):
x1 = 4 + random.random() * 2
x2 = 4 + random.random() * 2
x1, x2 = min(x1, x2), max(x1, x2)
assert t.get_dsdx(np.array([x1, x2])) == approx([
(pi * 2**2 / 4 - pi * 4**2 / 4) / 2
])
def test_tube_dsdx_1():
xs = [1, 2, 4]
ds = [1, 1, 1]
s = pi / 4
t = Tube(xs, ds)
for i in range(33):
x1 = -10 + random.random() * 30
x2 = -10 + random.random() * 30
x1, x2 = min(x1, x2), max(x1, x2)
assert t.get_dsdx(np.array([x1, x2])) == approx([0.0])
def test_tube_ws():
xs = [1, 2, 4]
ds = [1, 1, 1]
s = pi / 4
t = Tube(xs, ds)
for i in range(33):
x1 = -10 + random.random() * 30
x2 = -10 + random.random() * 30
x1, x2 = min(x1, x2), max(x1, x2)
assert t.get_W_between(x1, x2) == approx(s * (x2 - x1))
def test_tube_get_x2x1():
xs = [0, 2, 4, 6]
ds = [1, 2, 4, 2]
tube = Tube(xs, ds)
for i in range(1000):
x1 = np.random.uniform(0, 6)
w = np.random.uniform(1, 10)
x2 = tube.get_x2(x1, w)
xx1 = tube.get_x1(x2, w)
assert x1 == approx(xx1)
def _pour(self, source_tube: Tube, destination_tube: Tube, can_pour=False):
if can_pour or self.canPour(source_tube, destination_tube):
pour_liquid: Liquid = source_tube.removeLiquid()
destination_tube.addLiquid(pour_liquid.getColor())
try:
self._pour(source_tube, destination_tube)
except (ValueError):
pass
else:
raise ValueError("Cannot pour tube: {} into tube:{}".format(
source_tube.getName(), destination_tube.getName()))
def test_tube_s():
d = sqrt(4 / pi) # s = 1
ds = np.array([d, d, 0.5 * d])
xs = [-1, 2, 4]
t = Tube(xs, ds)
assert t.get_S(np.array([-10, -1, 2],
dtype=np.double)) == approx([1, 1, 1])
assert t.get_S(np.array([2, 4, 55], dtype=np.double)) == approx(
[1, pi * (0.5 * d)**2 / 4, pi * (0.5 * d)**2 / 4])
assert t.get_S(np.array([3], dtype=np.double)) == approx(
[pi * (0.5 * d)**2 / 4 * 0.5 + 0.5])
class tubeui():
def __init__(self, receiver):
self.root = Tk()
self.m = Tube(self.root)
self.m.receiver = receiver
self.root.title("Play Youtube URL")
self.root.protocol("WM_DELETE_WINDOW", self.on_exit)
self.root.mainloop()
def on_exit(self):
self.m.on_closing()
self.root.destroy()
def test_tube_d():
ds = np.array([1, 1, 0.5])
xs = [1, 2, 4]
t = Tube(xs, ds)
assert t.get_ds() == approx(ds)
assert t.get_xs() == approx(xs)
assert t.get_d(3) == approx(0.75)
assert t.get_d(33) == approx(0.5)
def all_transformers():
return [
Email(),
SMS(),
FBMsg(),
Phone(),
BankWire(),
Paypal(),
DebitCard(),
ContactlessCard(),
Tube(),
FBStatus(),
Tweet(),
]
def create_items(self):
"""get items symbol instead of its character in the text file
(given in each class),
for each item in the "items" tupple (given in Maze constructor),
at the position (pos) given in get_random_empty_tile method
pos= [line, column]"""
for item in self.items:
pos = self.get_random_empty_tile()
if item == "N":
self.data[pos[0]][pos[1]] = Needle()
elif item == "E":
self.data[pos[0]][pos[1]] = Ether()
elif item == "T":
self.data[pos[0]][pos[1]] = Tube()
def test_ndaisies(n_daisies):
P = 1
gamma = 0.3
a_vec = np.array([1 / (n_daisies + 1) for i in range(n_daisies)])
#A_vec = np.random.uniform(0, 0.5, size=n_daisies)
A_vec = np.linspace(0.05, 0.75, n_daisies)
T_vec = np.random.normal(295., 10., size=n_daisies)
#T_vec = 295 * np.ones(n_daisies)
#tube = Tube(P=1, gamma=0.3,
#a_vec=np.array([1/(n_daisies + 1) for i in range(n_daisies)]),
#A_vec=np.random.uniform(size=n_daisies),
#T_vec=np.random.normal(295., 10., size=n_daisies))
#tube.setupGrid(40, 40, 80)
#tube._updategrid()
#phis = [0, 1.57, 3.14, 4.71]
phis = np.linspace(-0.39, 0.39, 9)
phis = [0.]
for phi in phis:
tube = Tube(P=P,
gamma=gamma,
a_vec=a_vec,
A_vec=A_vec,
phi=phi,
T_vec=T_vec)
tube.setupGrid(0, 0, 80, oceans=True, inputfile='test.world')
#tube.plot(r'Daisyworld init', ptype='albedo')
for i in range(100):
print(f"{i}")
tube._updategrid()
tube.plot(f"Daisyworld w/ {n_daisies} daisies")
tube.plot(f"Daisyworld w/ {n_daisies} daisies", ptype='albedo')
def create_tubes(n):
tubes = []
row_width = TUBE_WIDTH * (n / 2) + TUBE_WIDTH * ((n / 2) - 1)
row_space = TUBE_WIDTH # space between each tube
col_space = TUBE_WIDTH * 2 # space between each row
sx = 0 - (row_width // 2)
sxv = sx
sy = 0 + col_space // 2 + TUBE_HEIGHT
for i in range(n):
if i == (n // 2):
sy -= TUBE_HEIGHT + col_space
sxv = sx
tubes.append(
Tube(str(i + 1), sxv, sy, TUBE_WIDTH, TUBE_HEIGHT,
LIQUID_UNIT_VOLUME, LIQUID_PER_TUBE))
sxv += TUBE_WIDTH + row_space
return tubes
def read_tube_quotes():
with open('../data/competition_data/temp/tube.csv', 'r') as tube_file:
tube_reader = csv.DictReader(tube_file)
tubes = {}
for row in tube_reader:
tubes[row['tube_assembly_id']] = Tube(row['tube_assembly_id'], row['material_id'], float(row['diameter']),
float(row['wall']), float(row['length']),
float(row['num_bends']), float(row['bend_radius']))
print 'Number of tubes ', len(tubes)
with open('../data/competition_data/temp/train_set.csv', 'r') as train_file:
train_reader = csv.DictReader(train_file)
tube_quotes = []
for row in train_reader:
tube = tubes[row['tube_assembly_id']]
tube_quotes.append(
TubeQuote(tube, row['supplier'], row['quote_date'], float(row['annual_usage']), float(row['cost']),
float(row['quantity']), is_bracket_pricing(row)))
print 'Number of tube quotes ', len(tube_quotes)
return tube_quotes
def canPour(_, source_tube: Tube, destination_tube: Tube):
pouring_liquid: Liquid = source_tube.getTopLiquid()
not_null = pouring_liquid is not None
pourable = not_null and destination_tube.canAddLiquid(pouring_liquid)
return pourable
def newtube(filename):
tube = Tube(filename)
return tube
T_vec = np.random.normal(295., 10., size=n_daisies).sort()
#tube = Tube(P=1, gamma=0.3,
#a_vec=np.array([1/(n_daisies + 1) for i in range(n_daisies)]),
#A_vec=np.random.uniform(size=n_daisies),
#T_vec=np.random.normal(295., 10., size=n_daisies))
#tube.setupGrid(40, 40, 80)
#tube._updategrid()
#phis = [0, 1.57, 3.14, 4.71]
phis = np.linspace(-0.39, 0.39, 9)
phis = [0.]
for phi in phis:
tube = Tube(P=P,
gamma=gamma,
a_vec=a_vec,
A_vec=A_vec,
phi=phi,
T_vec=T_vec)
tube.setupGrid(0, 0, 80, oceans=True, inputfile='harrison.world')
tube.plot(r'Daisyworld init', savefig="temps_init.png")
tube.plot(r'Daisyworld init albedos',
ptype='albedo',
savefig='albedos_init.png')
#tube.plot(r'Daisyworld init', ptype='albedo')
for i in range(100):
print(f"{i}", end="\r")
tube._updategrid()
tube.plot(f'Daisyworld at {i} iterations',
savefig=f'figures/frame_{i:03d}.png',
def test_tube_exists():
t = Tube([1, 2, 3], [1, 0, 0])
assert t is not None
def __init__(self):
super(VoiceGame2, self).__init__(255, 255, 255, 255, WIDTH, HEIGHT)
pygame.mixer.init()
self.cloud = cocos.sprite.Sprite('fla.png')
self.cloud.scale_x = 1.5
self.cloud.scale_y = 1.83
self.cloud.position = 300, 240
self.add(self.cloud)
self.gameover = None
self.score = 0 #count score
self.txt_score = cocos.text.Label(u'Score：0',
font_name=FONTS,
font_size=16,
color=BLACK)
self.txt_score.position = 510, 240
self.add(self.txt_score, 99999)
self.top = '', 0
self.top_notice = cocos.text.Label(u'',
font_name=FONTS,
font_size=18,
color=BLACK)
self.top_notice.position = 400, 410
self.add(self.top_notice, 99999)
self.name = ''
# init voice
self.NUM_SAMPLES = 2048 # pyAudio cache size
self.LEVEL = 1500 # sound threshold
'''self.voicebar = Sprite('black.png', color=(0, 0, 255))
self.voicebar.position = 20, 450
self.voicebar.scale_y = 0.1
self.voicebar.image_anchor = 0, 0
self.add(self.voicebar)'''
self.ppx = Flappy(self)
self.add(self.ppx)
self.floor2 = cocos.cocosnode.CocosNode()
self.floor = cocos.cocosnode.CocosNode()
self.add(self.floor)
self.add(self.floor2)
self.last_block = 0, 100
for i in range(5):
b = Tube(self)
u = upTube(self)
self.floor.add(b)
self.floor.add(u)
self.pitch_pic(u)
pos = b.x + b.width, b.height
# start inputing sound
pa = PyAudio()
SAMPLING_RATE = int(
pa.get_device_info_by_index(0)['defaultSampleRate'])
self.stream = pa.open(format=paInt16,
channels=1,
rate=SAMPLING_RATE,
input=True,
frames_per_buffer=self.NUM_SAMPLES)
self.stream.stop_stream()
pygame.music.load('intro.wav'.encode())
pygame.music.play(1)
self.schedule(self.update)
import json
import os
import sys
from math import *
wd = os.path.abspath(__file__) # os.path.dirname(os.path.dirname(os.getcwd()))
wd = os.path.dirname(os.path.dirname(wd))
sys.path.append(wd + "\\src\\include\\godunov")
sys.path.append(wd + "\\src")
import numpy as np
from gaslayer import Powder, PowderOvLayer, GridStrecher, GasFluxCalculator
from tube import Tube
d = 23 * 1e-3
barrel = Tube([0, 1], [d, d])
with open('gpowders.json') as f:
all_powders = json.load(f)
print(all_powders.keys())
def _plot3():
import matplotlib.pyplot as plt
# из статьи ОДНОМЕРНЫЕ ЗАДАЧИ ГАЗОВОЙ ДИНАМИКИ И ИХ РЕШЕНИЕ ПРИ ПОМОЩИ РАЗНОСТНЫХ СХЕМ ВЫСОКОЙ РАЗРЕШАЮЩЕЙ СПОСОБНОСТИ
# LEFT RIGHT
# ro u p ro u p t
v = [
(1, 0, 1, 0.125, 0, 0.1, 0.15),
# ( 0.445, 0.698, 3.528, 0.5, 0, 0.571, 0.05 ),
# ( 1, 1, 1, 0.5, 0, 0.571, 0.05 )
]
for ro_1, u_1, p_1, ro_2, u_2, p_2, t in v:
d = {
'p_1': p_1, # давление слева
'ro_1': ro_1, # плотность слева
'u_1': u_1, # скорость слева
'p_2': p_2, # давление справа
'ro_2': ro_2, # плотность справа
'u_2': u_2, # скорость справа
'p_0': 0, # параметр в ур-ии состояния
'gamma': 1.4, # параметр в ур-ии состояния
'c_0': 0, # параметр в ур-ии состояния
'eps_F': 1e-6, # точность определения решения
'n_iter_max':
100, # максимальное количество итераций при определении решения
'x0': 0.5, # положение разрыва в момент t=0
'ts': [
t
], # времена, в которых нужно построить графики распределения параметров
'n':
10000 # кол-во точек, в которых ищутся параметры волны разрежения
}
# plot_distrs(**d)
# print(get_distrs_to_time(d['ts'][0], **d))
x1 = 0
x2 = 1
def init_foo(x, *args):
if x <= 0.5:
return d['ro_1'], d['p_1'], d['u_1']
return d['ro_2'], d['p_2'], d['u_2']
gas_eos = GasEOS(gamma=1.4, kind=1)
grid_strecher = GridStrecher(strech_type=2,
st2_window_part=0.05,
st2_adapt_prop=0.2,
D_mnj=1)
gas_flux_calculator = GasFluxCalculator(x_order=2, alpha_1=3, alpha_2=1)
tube = Tube([0, 1], [0.1, 0.1])
n_cells = 300
layer = GasLayer(n_cells,
tube=tube,
gasEOS=gas_eos,
flux_calculator=gas_flux_calculator,
grid_strecher=grid_strecher,
n_qs=3)
layer.xs_borders[:] = np.linspace(x1, x2, n_cells + 1)
layer.init_ropue_fromfoo(init_foo)
# d = layer.to_dict()
# grid_strecher.smooth_arr(layer.xs_cells, layer.es, layer.es, grid_strecher.st2_window_part)
# grid_strecher.adaptine_borders(layer.xs_borders, layer.es, layer.xs_borders)
# layer.init_ropue_fromfoo(init_foo)
# grid_strecher.smooth_arr(layer.xs_cells, layer.es, layer.es, grid_strecher.st2_window_part)
# grid_strecher.adaptine_borders(layer.xs_borders, layer.es, layer.xs_borders)
# layer.init_ropue_fromfoo(init_foo)
def plot_layer(lr, plt_ideal=True):
lr_d = layer.to_dict()
plt.scatter(lr_d['xs_cells'], lr_d['ros'])
plt.scatter(lr_d['xs_cells'], lr_d['ps'])
plt.scatter(lr_d['xs_cells'], lr_d['us'])
plt.scatter(lr_d['xs_cells'], lr_d['es'])
# plt.scatter(lr_d['xs_borders'], lr_d['bettas'])
# plt.scatter(lr_d['xs_borders'], lr_d['fluxes'][0])
if plt_ideal:
dd = get_distrs_to_time(layer.time, **d)
plt.plot(dd['xs'], dd['ros'], label=r'$\rho$')
plt.plot(dd['xs'], dd['ps'], label=r'$p$')
plt.plot(dd['xs'], dd['us'], label=r'$u$')
plt.plot(dd['xs'], dd['es'], label=r'$e$')
plt.grid(True)
plt.legend()
plt.show()
layer.init_taus_acustic()
t0 = time.time()
while layer.time < d['ts'][0]:
# d['ts'][0] = 0.001
# layer.time = 0.01
# break
layer.fill_rr()
layer1 = layer.copy()
tau = layer.get_tau_min() * 0.3
suc = layer.grid_strecher.sync_layers(layer, layer1, tau, 0, 0)
# plt.plot(np.array(layer.xs_borders), label='layer.xs_borders')
# plt.plot(np.array(layer1.xs_borders), label='layer1.xs_borders')
# plt.plot(np.array(layer.Vs_borders), label='layer.Vs_borders')
# plt.plot(np.array(layer1.Vs_borders), label='layer1.Vs_borders')
# plt.grid(True)
# plt.legend()
# plt.show()
layer.fill_taus()
layer1 = layer.step_simple(tau, 0, 0)
if layer == layer1:
break
layer2 = layer.corrector_bogdanov(layer1, 0, 0)
if layer == layer2:
break
layer = layer2
# plot_layer(layer, False)
# print(np.max(np.array(layer.bettas)))
print(time.time() - t0)
#(3.55189 + 3.40513 + 3.33072 + 3.44629 + 3.717145 + 3.93337 + 3.94355 + 3.706031+3.54699+3.4006)
# plot_layer(layer)
print(layer.time)
# print(layer.to_dict())
plot_layer(layer)
def tube(request):
return Tube([1, 2, 3], [0.1, 0.2, 0.15])
