Коммит 6934b1bc создал по автору vasev's avatar vasev
Просмотр файлов

Initial commit

владельцы
# Примеры по модели параллельных вычислений PAR
Описание модели см. model.md
## Подготовка
Необходимо установить пакет PPK. Выберите каталог для размещения, войдите в него и выполните:
```
git clone https://github.com:pavelvasev/ppk.git
# if have github account: git clone git@github.com:pavelvasev/ppk.git
cd ppk
python3 -m pip install -e .
```
## Запуск
Зайти в папку примера и выполнить скрипт вида run-*.sh
## Лицензия
MIT
2026 (c) Павел Васёв
ИММ УрО РАН
\ Нет новой строки в конце файла
Математические коды: 2026 (c) Артём Королев, Юрий Авербух
![My Image](animation.gif)
\ Нет новой строки в конце файла
#!/usr/bin/env python3
"""
Сборка PNG-кадров и создание анимации из распределённых .npy снимков.
Автоматически определяет сохранённые шаги.
PNG сохраняются в snapshots_png/, анимация в корне res_dir/.
"""
import os
import sys
import glob
import json
import time
import argparse
import numpy as np
import matplotlib.pyplot as plt
import imageio.v2 as imageio
def load_ranges(res_dir):
json_path = os.path.join(res_dir, "checkpoint", "ranges.json")
if os.path.isfile(json_path):
with open(json_path, "r") as f: return json.load(f)
raise FileNotFoundError("ranges.json not found. Run calculation first.")
def get_available_steps(snapshots_npy_dir):
pattern = os.path.join(snapshots_npy_dir, "snapshot_step_*.npy")
files = glob.glob(pattern)
steps = set()
for f in files:
try:
step_str = os.path.basename(f).split("_step_")[1].split("_")[0]
steps.add(int(step_str))
except (IndexError, ValueError):
continue
return sorted(list(steps))
def assemble_step(res_dir, step, Nx=None, Ny=None):
"""Собирает полное поле из .npy чанков. Размеры берутся из ranges.json, если не заданы."""
snap_dir = os.path.join(res_dir, "checkpoint")
pattern = os.path.join(snap_dir, f"snapshot_step_{step:06d}_r*.npy")
files = glob.glob(pattern)
if not files:
return None
# 🔑 Загружаем ranges.json и берём размеры оттуда
ranges_data = load_ranges(res_dir)
if Nx is None: Nx = ranges_data.get('global_Nx', 4096)
if Ny is None: Ny = ranges_data.get('global_Ny', 4096)
ranges_list = ranges_data['rank_ranges']
full = np.zeros((Ny, Nx), dtype=np.float32)
#print(full.shape)
for fpath in files:
try:
rank = int(os.path.splitext(os.path.basename(fpath))[0].split('_r')[1])
r_info = next((r for r in ranges_list if r['rank'] == rank), None)
#print("=============",r_info,rank)
if r_info is None: continue
d = np.load(fpath)
#print(d)
full[r_info['j_start']:r_info['j_end'], r_info['i_start']:r_info['i_end']] = d
#print("printed into full",r_info['j_start'],r_info['j_end'], r_info['i_start'],r_info['i_end'])
except Exception as e:
print("exception",e)
continue
return full
def save_png(full, step, h, snapshots_png_dir, vmin=0, vmax=100, max_size=1024):
sub = max(1, max(full.shape) // max_size)
ix = np.arange(0, full.shape[1], sub)
iy = np.arange(0, full.shape[0], sub)
if ix[-1] != full.shape[1]-1: ix = np.append(ix, full.shape[1]-1)
if iy[-1] != full.shape[0]-1: iy = np.append(iy, full.shape[0]-1)
b_small = full[np.ix_(iy, ix)]
extent = [ix[0]*h, ix[-1]*h, iy[0]*h, iy[-1]*h]
plt.figure(figsize=(6, 5))
plt.imshow(b_small, origin="lower", extent=extent, vmin=vmin, vmax=vmax, interpolation="nearest")
plt.colorbar(label="β"); plt.xlabel("x"); plt.ylabel("y"); plt.title(f"Step {step}")
plt.tight_layout()
out_path = os.path.join(snapshots_png_dir, f"frame_step_{step:06d}.png")
plt.savefig(out_path, dpi=150, bbox_inches="tight"); plt.close()
return out_path
def main():
t_start = time.perf_counter()
parser = argparse.ArgumentParser(description="Сборка PNG и анимации из MPI-снимков")
parser.add_argument("--res-dir", type=str, required=True)
parser.add_argument("--steps", type=int, nargs="*", default=None)
parser.add_argument("--Nx", type=int, default=4096)
parser.add_argument("--Ny", type=int, default=4096)
parser.add_argument("--h", type=float, default=0.5)
parser.add_argument("--format", choices=["gif", "mp4"], default="gif")
parser.add_argument("--fps", type=int, default=10)
args = parser.parse_args()
print(f"🚀 Инициализация сборки в {args.res_dir}...")
snapshots_npy_dir = os.path.join(args.res_dir, "checkpoint")
snapshots_png_dir = os.path.join(args.res_dir, "snapshots_png")
os.makedirs(snapshots_png_dir, exist_ok=True)
if args.steps is None:
steps = get_available_steps(snapshots_npy_dir)
if not steps:
print("❌ Не найдено .npy файлов. Убедитесь, что расчёт завершился с SAVE_SNAPSHOT_FOLDER=True.")
return
print(f"🔍 Автоматически обнаружены шаги: {steps}")
else:
steps = args.steps
print(f"📌 Используются заданные шаги: {steps}")
t_load, t_png, t_enc = 0.0, 0.0, 0.0
png_paths = []
for step in steps:
print(f" → Шаг {step}...", end=" ", flush=True)
t0 = time.perf_counter()
full = assemble_step(args.res_dir, step, None, None)
#print("full=",full.shape)
t_load += time.perf_counter() - t0
if full is None: print("❌ не найден"); continue
t1 = time.perf_counter()
p = save_png(full, step, args.h, snapshots_png_dir,0,100,4096)
t_png += time.perf_counter() - t1
png_paths.append(p)
print(f"✅ {os.path.basename(p)}")
if png_paths:
print(f"🎞️ Кодирование анимации ({args.format}, {args.fps} fps)...")
t2 = time.perf_counter()
frames = [imageio.imread(p) for p in sorted(png_paths)]
out_path = os.path.join(args.res_dir, f"animation.{args.format}")
if args.format == "gif":
imageio.mimsave(out_path, frames, fps=args.fps, loop=0)
else:
imageio.mimsave(out_path, frames, fps=args.fps, codec="libx264")
t_enc = time.perf_counter() - t2
print(f"🎬 Анимация сохранена: {out_path}")
else:
print("⚠️ Не удалось собрать ни одного кадра.")
t_total = time.perf_counter() - t_start
t_total = time.perf_counter() - t_start
# === ДОБАВЛЕНИЕ ФАЗЫ 2 В ОБЩИЙ ЖУРНАЛ ===
import datetime
log_path = os.path.join(args.res_dir, "general.log")
# Если файл ещё не создан (например, запуск только постобработки), создаём его
if not os.path.exists(log_path):
with open(log_path, "w") as f:
f.write("=== ОБЩИЙ ЖУРНАЛ ВЫПОЛНЕНИЯ ===\n")
f.write("-" * 40 + "\n")
now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
with open(log_path, "a") as f:
f.write(f"--- Фаза 2: Постобработка ({now}) ---\n")
f.write(f"Обработано шагов: {steps} (всего {len(steps)})\n")
f.write(f"Сгенерировано PNG: {len(png_paths)}\n")
f.write(f"Анимация: animation.{args.format} ({args.fps} fps)\n")
f.write(f"Длительность: {t_total:.2f} сек\n")
f.write(f"Статус: УСПЕШНО\n")
f.write("-" * 40 + "\n")
f.write("=== КОНЕЦ ЖУРНАЛА ===\n")
if __name__ == "__main__":
main()
\ Нет новой строки в конце файла
import os
import numpy as np
def save_checkpoint(beta, step, mass_history, times, checkpoint_dir,
extra_params=None, snapshot_history=None):
os.makedirs(checkpoint_dir, exist_ok=True)
np.save(os.path.join(checkpoint_dir, "beta.npy"), beta)
np.save(os.path.join(checkpoint_dir, "mass_history.npy"), np.array(mass_history, dtype=np.float64))
np.save(os.path.join(checkpoint_dir, "times.npy"), np.array(times, dtype=np.float64))
with open(os.path.join(checkpoint_dir, "step.txt"), "w") as f:
f.write(str(step))
if extra_params is not None:
np.save(os.path.join(checkpoint_dir, "extra_params.npy"), extra_params)
# Сохраняем snapshot_history как отдельные файлы
if snapshot_history is not None:
# Удаляем старые файлы снимков, чтобы не было конфликтов
for f in os.listdir(checkpoint_dir):
if f.startswith('snapshot_') and f.endswith('.npy'):
os.remove(os.path.join(checkpoint_dir, f))
for snap_step, arr in snapshot_history.items():
np.save(os.path.join(checkpoint_dir, f"snapshot_{snap_step}.npy"), arr)
print(f"Чекпоинт сохранён на шаге {step} в {checkpoint_dir}")
def load_checkpoint(checkpoint_dir, required_shape=None, required_params=None):
step_file = os.path.join(checkpoint_dir, "step.txt")
beta_file = os.path.join(checkpoint_dir, "beta.npy")
mass_file = os.path.join(checkpoint_dir, "mass_history.npy")
times_file = os.path.join(checkpoint_dir, "times.npy")
if not (os.path.isfile(step_file) and os.path.isfile(beta_file) and
os.path.isfile(mass_file) and os.path.isfile(times_file)):
return 0, None, None, None, None
try:
with open(step_file, "r") as f:
step = int(f.read().strip())
beta = np.load(beta_file)
if required_shape and beta.shape != required_shape:
print(f"Несовместимость формы beta: {beta.shape} != {required_shape}")
return 0, None, None, None, None
mass_history = np.load(mass_file).tolist()
times = np.load(times_file).tolist()
# Загружаем snapshot_history из отдельных файлов
snapshot_history = {}
for f in os.listdir(checkpoint_dir):
if f.startswith('snapshot_') and f.endswith('.npy'):
snap_step = int(f.split('_')[1].split('.')[0])
arr = np.load(os.path.join(checkpoint_dir, f))
snapshot_history[snap_step] = arr
if snapshot_history:
print(f"Загружено {len(snapshot_history)} снимков для композита")
# Проверка параметров (опционально)
extra_file = os.path.join(checkpoint_dir, "extra_params.npy")
if required_params and os.path.isfile(extra_file):
saved = np.load(extra_file, allow_pickle=True).item()
for key, val in required_params.items():
if key not in saved:
print(f"Параметр {key} отсутствует в чекпоинте")
return 0, None, None, None, None
if isinstance(val, float) and isinstance(saved[key], float):
if abs(val - saved[key]) > 1e-9:
print(f"Несовместимость {key}: {saved[key]} != {val}")
return 0, None, None, None, None
elif saved[key] != val:
print(f"Несовместимость {key}: {saved[key]} != {val}")
return 0, None, None, None, None
print(f"Загружен чекпоинт из {checkpoint_dir}, шаг {step}")
return step + 1, beta, mass_history, times, snapshot_history
except Exception as e:
print(f"Ошибка загрузки чекпоинта: {e}")
return 0, None, None, None, None
\ Нет новой строки в конце файла
import numpy as np
from numba import njit, prange
@njit(parallel=True)
def euler_step(beta, Nx, Ny, vx, vy, g_val, h, dt):
"""
Один шаг явного метода Эйлера для уравнения переноса с линейным стоком.
Интенсивности переходов вычисляются на лету, чтобы не хранить отдельные массивы.
"""
for j in prange(Ny):
for i in range(Nx):
k = i + Nx * j
# Локальные интенсивности для текущей ячейки
int_x = abs(vx[j, i]) / h
int_y = abs(vy[j, i]) / h
# Приток
rhs_k = 0.0
if i > 0 and vx[j, i-1] > 0:
rhs_k += (abs(vx[j, i-1]) / h) * beta[(i-1) + Nx*j]
if i < Nx-1 and vx[j, i+1] < 0:
rhs_k += (abs(vx[j, i+1]) / h) * beta[(i+1) + Nx*j]
if j > 0 and vy[j-1, i] > 0:
rhs_k += (abs(vy[j-1, i]) / h) * beta[i + Nx*(j-1)]
if j < Ny-1 and vy[j+1, i] < 0:
rhs_k += (abs(vy[j+1, i]) / h) * beta[i + Nx*(j+1)]
# Отток
outflow = 0.0
if vx[j, i] > 0 and i < Nx-1:
outflow += int_x
elif vx[j, i] < 0 and i > 0:
outflow += int_x
if vy[j, i] > 0 and j < Ny-1:
outflow += int_y
elif vy[j, i] < 0 and j > 0:
outflow += int_y
rhs_k -= outflow * beta[k]
# Источник/сток
rhs_k += g_val[j, i] * beta[k]
# Обновление beta на месте
beta[k] += dt * rhs_k
@njit(parallel=True)
def euler_step_two_buffer(beta_in, beta_out, Nx, Ny, vx, vy, g_val, h, dt):
# beta_in, beta_out уже двумерные массивы (Ny, Nx)
for j in prange(Ny):
for i in range(Nx):
rhs = 0.0
if i > 0 and vx[j, i-1] > 0:
rhs += (abs(vx[j, i-1]) / h) * beta_in[j, i-1]
if i < Nx-1 and vx[j, i+1] < 0:
rhs += (abs(vx[j, i+1]) / h) * beta_in[j, i+1]
if j > 0 and vy[j-1, i] > 0:
rhs += (abs(vy[j-1, i]) / h) * beta_in[j-1, i]
if j < Ny-1 and vy[j+1, i] < 0:
rhs += (abs(vy[j+1, i]) / h) * beta_in[j+1, i]
outflow = 0.0
if vx[j, i] > 0 and i < Nx-1:
outflow += abs(vx[j, i]) / h
elif vx[j, i] < 0 and i > 0:
outflow += abs(vx[j, i]) / h
if vy[j, i] > 0 and j < Ny-1:
outflow += abs(vy[j, i]) / h
elif vy[j, i] < 0 and j > 0:
outflow += abs(vy[j, i]) / h
rhs -= outflow * beta_in[j, i]
rhs += g_val[j, i] * beta_in[j, i]
beta_out[j, i] = beta_in[j, i] + dt * rhs
@njit
def max_abs_velocity(vx, vy):
"""Возвращает максимальное абсолютное значение скорости по обоим полям."""
max_v = 0.0
Ny, Nx = vx.shape
for j in range(Ny):
for i in range(Nx):
abs_vx = abs(vx[j, i])
abs_vy = abs(vy[j, i])
if abs_vx > max_v:
max_v = abs_vx
if abs_vy > max_v:
max_v = abs_vy
return max_v
\ Нет новой строки в конце файла
# параллельная версия par
##########################################
import os,sys
PROCID=int(os.environ["SLURM_PROCID"])
NPROCS=int(os.environ["SLURM_NPROCS"])
FIRST_NODE=os.environ["FIRST_NODE"]
PPK_PORT=3000
PPK_URL=f"ws://{FIRST_NODE}:{PPK_PORT}"
print("PROCID=",PROCID,"FIRST_NODE=",FIRST_NODE,"PPK_URL=",PPK_URL)
# отрубаем встроенную в np многопоточность
os.environ["OMP_NUM_THREADS"] = "1"
os.environ["OPENBLAS_NUM_THREADS"] = "1"
os.environ["MKL_NUM_THREADS"] = "1"
os.environ["VECLIB_MAXIMUM_THREADS"] = "1"
os.environ["NUMEXPR_NUM_THREADS"] = "1"
# после этого можно импортировать numpy
import numpy as np
import matplotlib.pyplot as plt
import time
import gc
import json
################## подключение par
parent_dir = os.path.dirname(os.path.abspath(__file__))
sibling_dir = os.path.join(parent_dir, '..', 'par')
sys.path.insert(0, os.path.abspath(sibling_dir))
import par
import ppkrunner
##################
from numba import njit
from core import euler_step_two_buffer, max_abs_velocity
from init import init_checkerboard, init_velocity_rotation
from visualization import save_snapshot, save_mass_plot, save_snapshots_composite
from checkpoint import save_checkpoint, load_checkpoint
import parallel
# ------------------------------------------------------------
# Параметры
# ------------------------------------------------------------
start = time.perf_counter()
script_dir = os.path.dirname(os.path.abspath(__file__))
# Имя папки для результатов
name_of_experiment = "rotation_4096x4096_1"
res_dir = os.path.join(script_dir, f"par_{name_of_experiment}")
os.makedirs(res_dir, exist_ok=True)
# ========== Параметры чекпоинтов, они же и снапшоты у нас будут ==========
CHECKPOINT_ENABLE = True # использовать чекпоинты
CHECKPOINT_EVERY = 50 # сохранять каждые N шагов
CHECKPOINT_DIR = os.path.join(res_dir, "checkpoint")
os.makedirs(CHECKPOINT_DIR, exist_ok=True)
# ========== Параметры сетки ==========
Nx = 4096
Ny = 4096
N = Nx * Ny
h = 0.5
dt = 0.01
T = 16.0
n_steps = int(T / dt)
# ========== Инициализация скоростей ==========
cx = (Nx - 1) / 2.0
cy = (Ny - 1) / 2.0
scale = 0.02
######################### создаем мир
g = par.graph()
# todo тут можно настроить и по колонкам, и по строкам, и по блокам
# для блоков можно придумать формулу f(NPROCS)
Nx_per_node = 2048 # на 1 узел
Ny_per_node = 2048
# размеры глобальной памяти по блокам
GRID_SHAPE = [Nx // Nx_per_node,Ny // Ny_per_node]
nodes = parallel.generate_nodes( GRID_SHAPE, NPROCS)
g.add_nodes( nodes )
# было
#vx, vy = init_velocity_rotation(Ny, Nx, h, cx, cy, scale)
# стало
r = par.rule().input("grid_pos").output("vx","vy").code( parallel.init_velocity_rotation,
Ny, Nx, h, cx, cy, scale, Nx_per_node, Ny_per_node ).limit(1)
g.add_rule( r )
# ========== Инициализация стока ==========
# было
#g_val = np.full((Ny, Nx), -0.2, dtype=np.float32)
# стало
r = par.rule().input("grid_pos").output("g_val").code( parallel.init_const_gval,
-0.2, Nx_per_node, Ny_per_node ).limit(1)
g.add_rule( r )
# ========== Начальное распределение ==========
block_size = Nx // 8
full_value = 100.0
# было
#beta2d = init_checkerboard(Ny, Nx, block_size, full_value)
#beta = beta2d.ravel()
# стало
r = par.rule().input("grid_pos").output("beta").code( parallel.init_checkerboard,
block_size,full_value, Nx_per_node, Ny_per_node ).limit(1)
g.add_rule( r )
# ========== Параметры визуализации ==========
#snapshots = [0, n_steps//3, (2*n_steps)//3, n_steps] # Моменты для составного изображения
#max_display_size = 1024 # ограничение на размерность изображения сетки
# ------------------------------------------------------------
# Проверка условия устойчивости (CFL)
# ------------------------------------------------------------
"""
todo
v_max = max_abs_velocity(vx, vy)
cfl = v_max * dt / h
print(f"v_max = {v_max}")
if cfl > 1.0:
print(f"Предупреждение: CFL = {cfl:.2f} > 1.0 – решение может быть неустойчивым")
gc.collect()
"""
# ------------------------------------------------------------
# Подготовка к началу интегрирования
# ------------------------------------------------------------
"""
checkpoint_params = {
'Nx': Nx,
'Ny': Ny,
'h': h,
'dt': dt,
'scale': scale,
'T': T,
'n_steps_total': n_steps,
}
snapshot_history = {}
if CHECKPOINT_ENABLE:
required_shape = (Ny, Nx)
required_params = {'Nx': Nx, 'Ny': Ny, 'h': h, 'dt': dt, 'n_steps_total': n_steps}
start_step, loaded_beta, loaded_mass, loaded_times, loaded_snaps = load_checkpoint(
CHECKPOINT_DIR, required_shape, required_params
)
else:
start_step = 0
loaded_beta = None
if start_step > 0 and loaded_beta is not None:
beta1 = loaded_beta
mass_history = loaded_mass
times = loaded_times
beta2 = np.empty_like(beta1)
snapshot_history = loaded_snaps if loaded_snaps is not None else {}
print(f"Расчёт продолжается с шага {start_step} (время {times[-1]:.2f})")
else:
start_step = 1
beta1 = beta2d.copy()
beta2 = np.empty_like(beta1)
mass_history = [np.sum(beta1, dtype=np.float64)]
times = [0.0]
print("Начинаем новый расчёт")
subsample = max(1, max(Nx, Ny) // max_display_size)
def get_subsample_indices(size, step):
indices = list(range(0, size, step))
if indices[-1] != size - 1:
indices.append(size - 1)
return np.array(indices)
indices_x = get_subsample_indices(Nx, subsample)
indices_y = get_subsample_indices(Ny, subsample)
x_coords = indices_x * h
y_coords = indices_y * h
plot_extent = [x_coords[0], x_coords[-1], y_coords[0], y_coords[-1]]
#=============================
#mass_history = [np.sum(beta, dtype=np.float64)]
b_mat = beta.reshape(Ny, Nx)
#times = [0.0]
if SAVE_COMPOSITE and 0 in snapshots and 0 not in snapshot_history:
b_small = b_mat[np.ix_(indices_y, indices_x)]
snapshot_history[0] = b_small
#=============================
#if SAVE_SNAPSHOT_FOLDER or SAVE_COMPOSITE or SAVE_MASS_PLOT:
if SAVE_SNAPSHOT_FOLDER:
snapshots_dir = os.path.join(res_dir, 'snapshots')
os.makedirs(snapshots_dir, exist_ok=True)
#if SAVE_COMPOSITE:
# snapshot_history = {}
# if 0 in snapshots:
# b_small = b_mat[np.ix_(indices_y, indices_x)]
# snapshot_history[0] = b_small
if SAVE_SNAPSHOT_FOLDER and loaded_beta is not None:
save_snapshot(beta2d, 0, dt, indices_x, indices_y, plot_extent, snapshots_dir, vmin=0, vmax=100)
"""
# ------------------------------------------------------------
# Основной цикл интегрирования
# ------------------------------------------------------------
#beta1 = beta2d # исходный массив
#beta2 = np.empty_like(beta1) # буфер
# вычисление
r = par.rule().input("grid_pos","beta","vx","vy","g_val").output("beta_computed")\
.code( parallel.euler_step, Ny, Nx, h, dt, Nx_per_node, Ny_per_node )
g.add_rule( r )
# обмен
parallel.generate_halo_data( nodes, GRID_SHAPE )
# выгрузка на следующую итерацию
r = par.rule().input("beta_computed").output("beta_ready_to_merge","sx_first_out","sx_last_out","sy_first_out","sy_last_out")\
.code( parallel.export_halo ).offset(1)
g.add_rule( r )
# загрузка в начале итерации
r = par.rule().input("beta_ready_to_merge","grid_pos","grid_shape","sx_first_in","sx_last_in","sy_first_in","sy_last_in")\
.output("beta").code( parallel.import_halo ).offset(1)
g.add_rule( r )
# заглушка без обменов
#r = par.rule().input("beta_computed").output("beta").code( par.copy )
#g.add_rule( r )
r = par.rule().input("vx").output("vx").code( par.copy )
g.add_rule( r )
r = par.rule().input("vy").output("vy").code( par.copy )
g.add_rule( r )
r = par.rule().input("g_val").output("g_val").code( par.copy )
g.add_rule( r )
if CHECKPOINT_ENABLE:
r = par.rule().input("block_num","beta").code( parallel.save_snapshot, CHECKPOINT_DIR ).every( CHECKPOINT_EVERY )
g.add_rule( r )
if PROCID == 0:
ranges = parallel.get_ranges_info(GRID_SHAPE,Nx,Ny,Nx_per_node,Ny_per_node)
print("Записываю ranges.json")
with open(os.path.join(CHECKPOINT_DIR, "ranges.json"), "w") as f:
json.dump(ranges, f)
print("graph complete",flush=True)
print(json.dumps(g,cls=par.json_encoder))
runner = ppkrunner.runner(NPROCS,PROCID,FIRST_NODE)
with runner.start():
runner.run( g,n_steps )
"""
for step in range(start_step, n_steps + 1):
euler_step_two_buffer(beta1, beta2, Nx, Ny, vx, vy, g_val, h, dt)
beta1, beta2 = beta2, beta1
mass_history.append(np.sum(beta1, dtype=np.float64))
times.append(step * dt)
b_mat = beta1.reshape(Ny, Nx)
b_small = b_mat[np.ix_(indices_y, indices_x)]
if SAVE_SNAPSHOT_FOLDER and (step % save_every == 0 or step == n_steps):
save_snapshot(beta1, step, dt, indices_x, indices_y, plot_extent, snapshots_dir, vmin=0, vmax=100)
# if step in snapshots:
# save_snapshot(beta1, step, dt, indices_x, indices_y, plot_extent, snapshots_dir, vmin=0, vmax=100)
if SAVE_COMPOSITE and step in snapshots:
b_mat = beta1.reshape(Ny, Nx)
b_small = b_mat[np.ix_(indices_y, indices_x)]
snapshot_history[step] = b_small
if CHECKPOINT_ENABLE and (step % CHECKPOINT_EVERY == 0 or step == n_steps):
extra = {'Nx': Nx, 'Ny': Ny, 'h': h, 'dt': dt, 'n_steps_total': n_steps}
save_checkpoint(beta1, step, mass_history, times, CHECKPOINT_DIR, extra, snapshot_history)
print(f"Изменение массы: начальная = {mass_history[0]:.1f}, конечная = {mass_history[-1]:.1f}, разница = {mass_history[-1] - mass_history[0]:.1f} ({(mass_history[-1]/mass_history[0]-1)*100:.4f}%)")
"""
end = time.perf_counter()
print(f"Время выполнения: {end - start:.4f} секунд")
#if SAVE_COMPOSITE and SAVE_SNAPSHOT_FOLDER:
# Словарь времени по шагу
# time_by_step = {i: times[i] for i in range(len(times))}
# build_composite_from_png(snapshots, time_by_step, snapshots_dir,
# os.path.join(res_dir, 'snapshots_composite.png'))
# Визуализация
# ------------------------------------------------------------
"""
max_mass = max(mass_history)
min_mass = min(mass_history)
if SAVE_MASS_PLOT:
save_mass_plot(times, mass_history, res_dir)
if SAVE_COMPOSITE and snapshot_history:
save_snapshots_composite(snapshot_history, times, snapshots, plot_extent, res_dir)
"""
\ Нет новой строки в конце файла
import numpy as np
from numba import njit
# Шахматное поле
@njit
def init_checkerboard(Ny, Nx, block_size, full_value):
beta2d = np.zeros((Ny, Nx), dtype=np.float32)
for j in range(Ny):
for i in range(Nx):
if ((i // block_size) + (j // block_size)) % 2 == 1:
beta2d[j, i] = full_value
return beta2d
# Поле скоростей для вращения против часовой стрелки
@njit
def init_velocity_rotation(Ny, Nx, h, cx, cy, scale):
vx = np.zeros((Ny, Nx), dtype=np.float32)
vy = np.zeros((Ny, Nx), dtype=np.float32)
for j in range(Ny):
for i in range(Nx):
vx[j, i] = -(j - cy) * h * scale
vy[j, i] = (i - cx) * h * scale
if i == 0 or i == Nx-1 or j == 0 or j == Ny-1:
vx[j, i] = 0.0
vy[j, i] = 0.0
return vx, vy
\ Нет новой строки в конце файла
import numpy as np
import par
from numba import njit
import os
# создание основных узлов и блоков данных
# shape размеры распределенной памяти [блоков_x,блоков_y]
# block_shape размер 1 блока [x,y]
def generate_nodes(shape,workers_count):
nodes = []
idx = 0
for iy in range(shape[1]):
for ix in range(shape[0]):
n = par.node().set_name(f"node_{ix:02d}_{iy:02d}")
#n.add_data("cell",par.data().put(np.array(())))
n.add_data("vx",par.data().set_name("vx"))
n.add_data("vy",par.data().set_name("vy"))
n.add_data("g_val",par.data().set_name("g_val"))
n.add_data("beta",par.data().set_name("beta"))
n.add_data("beta_computed",par.data().set_name("beta_computed").put([]))
n.add_data("beta_ready_to_merge",par.data().set_name("beta_ready_to_merge"))
n.worker( idx % workers_count )
n.add_data("grid_shape",par.data().put(shape).const().set_name("grid_shape"))
n.add_data("grid_pos",par.data().put([ix,iy]).const().set_name("grid_pos"))
n.add_data("block_num",par.data().put(idx).const().set_name("block_num"))
#n.add_data("main",par.data().put(1).const().set_name("main"))
#n.add_data("block_shape",par.data().put(block_shape).const())
idx += 1
nodes.append(n)
return nodes
# создание блоков гало-данных
def generate_halo_data(nodes,shape):
idx = 0
EE = [] # значение для граничных граней
def getnode(nx,ny):
return nodes[ny*shape[0] + nx]
for ny in range(shape[1]):
for nx in range(shape[0]):
n = nodes[idx]
idx += 1
# x
d = par.data()
n.add_data("sx_first_out",d)
if nx > 0:
neib = getnode(nx-1,ny)
neib.add_data("sx_last_in",d.copy())
else:
n.add_data("sx_first_in",par.data().const().put(EE))
d = par.data()
n.add_data("sx_last_out",d)
if nx < shape[0]-1:
neib = getnode(nx+1,ny)
neib.add_data("sx_first_in",d.copy())
else:
n.add_data("sx_last_in",par.data().const().put(EE))
# y
d = par.data()
n.add_data("sy_first_out",d)
if ny > 0:
neib = getnode(nx,ny-1)
neib.add_data("sy_last_in",d.copy())
else:
n.add_data("sy_first_in",par.data().const().put(EE))
d = par.data()
n.add_data("sy_last_out",d)
if ny < shape[1]-1:
neib = getnode(nx,ny+1)
neib.add_data("sy_first_in",d.copy())
else:
n.add_data("sy_last_in",par.data().const().put(EE))
# выгружает грани
class export_halo:
def __init__(self):
pass
# idea мб выгружать все грани в массив 1 и все же их рассылать
def compute( self, grid):
faces = {
'sx_first': grid[1:-1,1], # первая плоскость по оси 0
'sx_last': grid[1:-1,-2], # последняя плоскость по оси 0
'sy_first': grid[1,1:-1], # первая плоскость по оси 1
'sy_last': grid[-2,1:-1], # последняя плоскость по оси 1
}
"""
# todo убрать copy попробовать
faces = {
'sx_first': grid[1:-1,1].copy(), # первая плоскость по оси 0
'sx_last': grid[1:-1,-2].copy(), # последняя плоскость по оси 0
'sy_first': grid[1,1:-1].copy(), # первая плоскость по оси 1
'sy_last': grid[-2,1:-1].copy(), # последняя плоскость по оси 1
}
"""
#return [faces]
return [grid, faces['sx_first'],faces['sx_last'],faces['sy_first'],faces['sy_last']]
# загружает грани
class import_halo:
def __init__(self):
pass
def compute( self, grid, grid_pos, grid_shape, sx_first,sx_last,sy_first,sy_last):
#return [np.zeros_like(grid)]
if grid_pos[0] > 0:
grid[1:-1, 0] = sx_first
if grid_pos[0] < grid_shape[0]-1:
grid[1:-1, -1] = sx_last
#print("::::::::::::::: import_halo from right, grid_pos",grid_pos,"node",self.node.name,"imported data",sx_last)
#print("thus now this grid",self.node.name,grid[1:-1, -1])
if grid_pos[1] > 0:
grid[0,1:-1] = sy_first
if grid_pos[1] < grid_shape[1]-1:
grid[-1,1:-1] = sy_last
#grid[1:-1, -1] = np.ones_like( grid[1:-1, -1] )*100
n = 2000 # number of random locations
value = 100 # value to add
#rows = np.random.randint(0, grid.shape[0], size=n)
#cols = np.random.randint(0, grid.shape[1], size=n)
#grid[rows, cols] = value
#print("ssss",sx_first, sx_last, sy_first,sy_last)
"""
if len(sx_first) > 0:
grid[0, 1:-1] = sx_first
if len(sx_last) > 0:
grid[-1, 1:-1] = sx_last
if len(sy_first) > 0:
grid[1:-1, 0] = sy_first
if len(sy_last) > 0:
grid[1:-1, -1] = sy_last
"""
"""
if len(sx_first) > 0:
grid[0, 1:-1] = sx_first
if len(sx_last) > 0:
grid[-2, 1:-1] = sx_last
if len(sy_first) > 0:
grid[1:-1, 1] = sy_first
if len(sy_last) > 0:
grid[1:-1, -2] = sy_last
"""
return [grid]
# функция порождает данные типа ranges для создания json файла
def get_ranges_info(shape,Nx, Ny, Nx_per_node, Ny_per_node):
ranges = {'rank_ranges': [], 'global_Nx': Nx, 'global_Ny': Ny}
idx = 0
for iy in range(shape[1]):
for ix in range(shape[0]):
jbig = iy * Ny_per_node
ibig = ix * Nx_per_node
ranges['rank_ranges'].append({
'rank': idx,
'j_start': jbig, 'j_end': jbig + Ny_per_node,
'i_start': ibig, 'i_end': ibig + Nx_per_node
})
idx += 1
return ranges
class init_velocity_rotation:
def __init__(self,Ny, Nx, h, cx, cy, scale, Nx_per_node, Ny_per_node):
self.Nx=Nx
self.Ny=Ny
self.h=h
self.cx = cx
self.cy = cy
self.scale=scale
self.Nx_per_node = Nx_per_node
self.Ny_per_node = Ny_per_node
def compute( self,grid_pos ):
vx = np.zeros((self.Ny_per_node+2, self.Nx_per_node+2), dtype=np.float32)
vy = np.zeros((self.Ny_per_node+2, self.Nx_per_node+2), dtype=np.float32)
for j in range(0,self.Ny_per_node+2):
for i in range(0,self.Nx_per_node+2):
# положение в глобальной сетке
jbig = grid_pos[1] * self.Ny_per_node + j-1
ibig = grid_pos[0] * self.Nx_per_node + i-1
vx[j, i] = -(jbig - self.cy) * self.h * self.scale
vy[j, i] = (ibig - self.cx) * self.h * self.scale
if ibig == 0 or ibig == self.Nx-1 or jbig == 0 or jbig == self.Ny-1:
vx[j, i] = 0.0
vy[j, i] = 0.0
return vx, vy
class init_const_gval:
def __init__(self,val, Nx_per_node, Ny_per_node):
self.val=val
self.Nx_per_node = Nx_per_node
self.Ny_per_node = Ny_per_node
def compute( self,grid_pos ):
g_val = np.full((self.Ny_per_node+2, self.Nx_per_node+2), self.val, dtype=np.float32)
return [g_val]
class init_checkerboard:
def __init__(self,block_size, full_value, Nx_per_node, Ny_per_node):
self.block_size=block_size
self.full_value = full_value
self.Nx_per_node = Nx_per_node
self.Ny_per_node = Ny_per_node
def compute( self,grid_pos ):
beta2d = np.zeros((self.Ny_per_node+2, self.Nx_per_node+2), dtype=np.float32)
for j in range(1,self.Ny_per_node+1):
for i in range(1,self.Nx_per_node+1):
# положение в глобальной сетке
jbig = grid_pos[1] * self.Ny_per_node + j
ibig = grid_pos[0] * self.Nx_per_node + i
if ((ibig // self.block_size) + (jbig // self.block_size)) % 2 == 1:
beta2d[j, i] = self.full_value
return [beta2d]
@njit(parallel=False)
def euler_step_two_buffer(beta_in, beta_out, Nx, Ny, vx, vy, g_val, h, dt, Nx_per_node, Ny_per_node):
# beta_in, beta_out уже двумерные массивы (Ny, Nx)
for j in range(1,Ny_per_node+1):
for i in range(1,Nx_per_node+1):
rhs = 0.0
# Приток (Upwind) - используем скорости из гало-слоёв
if vx[j, i-1] > 0:
rhs += (abs(vx[j, i-1]) / h) * beta_in[j, i-1]
if vx[j, i+1] < 0:
rhs += (abs(vx[j, i+1]) / h) * beta_in[j, i+1]
if vy[j-1, i] > 0:
rhs += (abs(vy[j-1, i]) / h) * beta_in[j-1, i]
if vy[j+1, i] < 0:
rhs += (abs(vy[j+1, i]) / h) * beta_in[j+1, i]
# Отток (без проверок границ, т.к. на физических краях vx=vy=0)
outflow = 0.0
if vx[j, i] > 0:
outflow += abs(vx[j, i]) / h
elif vx[j, i] < 0:
outflow += abs(vx[j, i]) / h
if vy[j, i] > 0:
outflow += abs(vy[j, i]) / h
elif vy[j, i] < 0:
outflow += abs(vy[j, i]) / h
rhs -= outflow * beta_in[j, i]
rhs += g_val[j, i] * beta_in[j, i]
beta_out[j, i] = beta_in[j, i] + dt * rhs
class euler_step:
def __init__(self,Nx,Ny,h,dt, Nx_per_node, Ny_per_node):
self.Nx=Nx
self.Ny=Ny
self.h=h
self.dt=dt
self.Nx_per_node = Nx_per_node
self.Ny_per_node = Ny_per_node
def compute( self,grid_pos,beta_in,vx,vy,g_val ):
# todo заменить на выходной буфер!
#print(";;;;;; going compute euler",self.node.name,"and right side is",beta_in[1:-1, -1])
# избегаем лишней аллокации #F-MEM-REUSE
beta_data = self.input_data[1]
if beta_data.prev_value is not None:
beta_out = beta_data.prev_value
#print("using beta from prev step!")
else:
beta_out = np.empty_like(beta_in)
euler_step_two_buffer(beta_in, beta_out, self.Nx, self.Ny, vx, vy, g_val,
self.h, self.dt,self.Nx_per_node,self.Ny_per_node)
return [beta_out]
class euler_step_alloc:
def __init__(self,Nx,Ny,h,dt, Nx_per_node, Ny_per_node):
self.Nx=Nx
self.Ny=Ny
self.h=h
self.dt=dt
self.Nx_per_node = Nx_per_node
self.Ny_per_node = Ny_per_node
def compute( self,grid_pos,beta_in,vx,vy,g_val ):
# todo заменить на выходной буфер!
#print(";;;;;; going compute euler",self.node.name,"and right side is",beta_in[1:-1, -1])
beta_out = np.empty_like(beta_in)
euler_step_two_buffer(beta_in, beta_out, self.Nx, self.Ny, vx, vy, g_val,
self.h, self.dt,self.Nx_per_node,self.Ny_per_node)
return [beta_out]
"""
class euler_step:
def __init__(self,Nx,Ny,h,dt, Nx_per_node, Ny_per_node):
self.Nx=Nx
self.Ny=Ny
self.h=h
self.dt=dt
self.Nx_per_node = Nx_per_node
self.Ny_per_node = Ny_per_node
@njit
def compute( self,grid_pos,beta_in,vx,vy,g_val ):
# todo заменить на выходной буфер!
beta_out = np.empty_like(beta_in)
for j in range(self.Ny_per_node):
for i in range(self.Nx_per_node):
rhs = 0.0
if i > 0 and vx[j, i-1] > 0:
rhs += (abs(vx[j, i-1]) / self.h) * beta_in[j, i-1]
if i < self.Nx-1 and vx[j, i+1] < 0:
rhs += (abs(vx[j, i+1]) / self.h) * beta_in[j, i+1]
if j > 0 and vy[j-1, i] > 0:
rhs += (abs(vy[j-1, i]) / self.h) * beta_in[j-1, i]
if j < self.Ny-1 and vy[j+1, i] < 0:
rhs += (abs(vy[j+1, i]) / self.h) * beta_in[j+1, i]
outflow = 0.0
if vx[j, i] > 0 and i < self.Nx-1:
outflow += abs(vx[j, i]) / self.h
elif vx[j, i] < 0 and i > 0:
outflow += abs(vx[j, i]) / self.h
if vy[j, i] > 0 and j < self.Ny-1:
outflow += abs(vy[j, i]) / self.h
elif vy[j, i] < 0 and j > 0:
outflow += abs(vy[j, i]) / self.h
rhs -= outflow * beta_in[j, i]
rhs += g_val[j, i] * beta_in[j, i]
beta_out[j, i] = beta_in[j, i] + self.dt * rhs
return [beta_out]
"""
class save_snapshot:
def __init__(self,snapshots_dir):
self.snapshots_dir=snapshots_dir
def compute( self,block_num,beta ):
np.save(os.path.join(self.snapshots_dir, f"snapshot_step_{self.iter_num:06d}_r{block_num}.npy"),
beta[1:-1, 1:-1])
return []
#!/bin/bash -ex
rm -rf par_rotation_4096x4096_1
APP="python3 example_rotation_par.py"
trap 'kill $(jobs -p) 2>/dev/null' EXIT
export FIRST_NODE=127.0.0.1
export SLURM_NPROCS=2
export PYTHONASYNCIODEBUG=1
SLURM_PROCID=0 $APP 0 >log1.txt 2>&1 &
SLURM_PROCID=1 $APP 1 >log2.txt 2>&1 &
wait
echo all-done
\ Нет новой строки в конце файла
#!/bin/bash -ex
APP=./run5.py
trap 'kill $(jobs -p) 2>/dev/null' EXIT
export FIRST_NODE=127.0.0.1
export SLURM_NPROCS=4
SLURM_PROCID=0 $APP 1 &
SLURM_PROCID=1 $APP 2 &
SLURM_PROCID=2 $APP 3 &
SLURM_PROCID=3 $APP 4 &
wait
echo all-done
\ Нет новой строки в конце файла
#!/bin/bash -ex
rm -rf par_rotation_4096x4096_1
APP="python3 example_rotation_par.py"
trap 'kill $(jobs -p) 2>/dev/null' EXIT
export FIRST_NODE=127.0.0.1
export SLURM_NPROCS=2
SLURM_PROCID=0 $APP 1 &
SLURM_PROCID=1 $APP 2 &
wait
echo all-done
./vis.sh
\ Нет новой строки в конце файла
#!/bin/bash -ex
python3 assemble_and_animate.py --res-dir=par_rotation_4096x4096_1
\ Нет новой строки в конце файла
import os
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np
def save_snapshot(beta, step, dt, indices_x, indices_y, plot_extent, snapshots_dir, vmin=0, vmax=100):
"""
Сохраняет текущее распределение как PNG.
beta – двумерный массив поля (Ny, Nx)
step – номер шага (используется в имени файла)
dt – шаг по времени
indices_x, indices_y – индексы для прореживания (чтобы уменьшить размер картинки)
plot_extent – [xmin, xmax, ymin, ymax] для imshow
snapshots_dir – папка для сохранения
vmin, vmax – диапазон цветовой шкалы
"""
b_small = beta[np.ix_(indices_y, indices_x)]
fig, ax = plt.subplots(figsize=(6, 5))
im = ax.imshow(b_small, origin='lower', extent=plot_extent, vmin=vmin, vmax=vmax, interpolation='nearest')
ax.set_title(f't = {step * dt:.2f} s')
ax.set_xlabel('x')
ax.set_ylabel('y')
plt.colorbar(im, ax=ax)
plt.tight_layout()
filename = f'snapshot_step_{step:06d}.png'
filepath = os.path.join(snapshots_dir, filename)
plt.savefig(filepath, dpi=150, bbox_inches='tight')
plt.close(fig)
print(f"Сохранён снимок: {filepath}")
def save_mass_plot(times, mass_history, script_dir, filename='total_mass.png'):
"""
Сохраняет график изменения суммарной массы.
"""
max_mass = max(mass_history)
min_mass = min(mass_history)
plt.figure()
plt.plot(times, mass_history, 'b-', label='Суммарная масса')
plt.xlabel('Время t')
plt.ylabel('Суммарная масса')
plt.title('Изменение общей массы')
if min_mass > max_mass * 0.9:
plt.ylim(max_mass * 0.95, max_mass * 1.05)
plt.legend()
plt.grid()
filepath = os.path.join(script_dir, filename)
plt.savefig(filepath, dpi=150, bbox_inches='tight')
print(f"График суммарной массы сохранён: {filepath}")
plt.close()
def save_snapshots_composite(snapshot_history, times, snapshots, plot_extent,
script_dir, vmin=0, vmax=100, filename='snapshots.png'):
"""
Сохраняет составное изображение из нескольких снимков распределения.
snapshot_history : dict {step: 2D_array}
times : список времён, соответствующих шагам
snapshots : список шагов, которые нужно отобразить
plot_extent : [xmin, xmax, ymin, ymax] для imshow
script_dir : папка для сохранения
vmin, vmax : диапазон цветовой шкалы
filename : имя выходного файла
"""
fig, axes = plt.subplots(1, len(snapshots), figsize=(12, 4))
for idx, snap in enumerate(snapshots):
b_small = snapshot_history[snap]
im = axes[idx].imshow(b_small, origin='lower', extent=plot_extent,
vmin=vmin, vmax=vmax, interpolation='nearest')
axes[idx].set_title(f't = {times[snap]:.2f}')
axes[idx].set_xlabel('x')
axes[idx].set_ylabel('y')
plt.colorbar(im, ax=axes[idx])
plt.tight_layout()
filepath = os.path.join(script_dir, filename)
plt.savefig(filepath, dpi=150, bbox_inches='tight')
print(f"Снимки распределения сохранены: {filepath}")
plt.close()
Игра жизнь 3d
* run-all.sh запуск на 2 процессах
* run-all-logs.sh запуск на 2 процессах с записью в лог
* run-all-x4.sh запуск на 4 процессах
При работе формируется папка output, там png по итерациям, плюс online.png текущая итерация.
![My Image](life-online.png)
\ Нет новой строки в конце файла
#!/bin/bash -ex
APP=./run5.py
trap 'kill $(jobs -p) 2>/dev/null' EXIT
export FIRST_NODE=127.0.0.1
export SLURM_NPROCS=2
export PYTHONASYNCIODEBUG=1
SLURM_PROCID=0 $APP 0 >log1.txt 2>&1 &
SLURM_PROCID=1 $APP 1 >log2.txt 2>&1 &
wait
echo all-done
\ Нет новой строки в конце файла
#!/bin/bash -ex
APP=./run5.py
trap 'kill $(jobs -p) 2>/dev/null' EXIT
export FIRST_NODE=127.0.0.1
export SLURM_NPROCS=4
SLURM_PROCID=0 $APP 1 &
SLURM_PROCID=1 $APP 2 &
SLURM_PROCID=2 $APP 3 &
SLURM_PROCID=3 $APP 4 &
wait
echo all-done
\ Нет новой строки в конце файла
#!/bin/bash -ex
APP=./run5.py
trap 'kill $(jobs -p) 2>/dev/null' EXIT
export FIRST_NODE=127.0.0.1
export SLURM_NPROCS=2
SLURM_PROCID=0 $APP 1 &
SLURM_PROCID=1 $APP 2 &
wait
echo all-done
\ Нет новой строки в конце файла
#!/bin/env python3
import asyncio
import traceback
#import ppk
import os
import time
import sys
import atexit
import subprocess
import json
import copy
import voxel_render_sw
import imageio
OUTPUT_DIR="output"
os.makedirs(OUTPUT_DIR, exist_ok=True)
print("hello world")
PROCID=int(os.environ["SLURM_PROCID"])
NPROCS=int(os.environ["SLURM_NPROCS"])
FIRST_NODE=os.environ["FIRST_NODE"]
PPK_PORT=3000
PPK_URL=f"ws://{FIRST_NODE}:{PPK_PORT}"
print("PROCID=",PROCID,"FIRST_NODE=",FIRST_NODE,"PPK_URL=",PPK_URL)
# отрубаем встроенную в np многопоточность
os.environ["OMP_NUM_THREADS"] = "1"
os.environ["OPENBLAS_NUM_THREADS"] = "1"
os.environ["MKL_NUM_THREADS"] = "1"
os.environ["VECLIB_MAXIMUM_THREADS"] = "1"
os.environ["NUMEXPR_NUM_THREADS"] = "1"
# после этого можно импортировать numpy
import numpy as np
from scipy.ndimage import convolve
################## подключение par
parent_dir = os.path.dirname(os.path.abspath(__file__))
sibling_dir = os.path.join(parent_dir, '..', 'par')
sys.path.insert(0, os.path.abspath(sibling_dir))
import par
import ppkrunner
##################
##############
##############
class render_voxels:
def __init__(self):
width, height = 1200, 800
self.renderer = voxel_render_sw.VoxelCubeRenderer(
img_width=width,
img_height=height,
dx=0,dy=0,dz=0,
fov_deg=60.0,
voxel_size=1.0,
#bg_color=(230, 230, 255),
bg_color=(0,0,0),
#cube_color=(200, 220, 255), # светлые грани
#edge_color=(20, 40, 120), # тёмные рёбра
cube_color=(20, 40, 120),
edge_color=(200, 220, 255),
edge_thickness=1,
)
def compute( self,grid,pos,shape ):
eye = (50, 50, 100.0)
center = (5.0, 5.0, 5.0)
up = (0.0, 1.0, 0.0)
#pos = params["pos"] # положение блока в сетке блоков
size = shape[0] # число ячеек в блоке
# дык это же grid.shape по идее
self.renderer.dx = pos[0] * size
self.renderer.dy = pos[1] * size
self.renderer.dz = pos[2] * size
rgb, depth = self.renderer.render(grid, eye=eye, center=center, up=up)
return [rgb, depth]
class merge_images:
def __init__(self):
pass
def compute( self,rgb1,depth1,rgb2,depth2 ):
rgb, depth = voxel_render_sw.merge_by_depth(rgb1,depth1,rgb2,depth2)
return [rgb, depth]
class random_voxels:
def __init__(self,size,density):
self.size=size
self.density = density
def compute( self,input_grid ):
grid = np.random.random((self.size, self.size, self.size)) < self.density
return [grid]
class game_of_life3d:
def __init__(self,rule="4555"):
#rule = "4555"
# Парсим правила
if rule == "4555":
self.birth = [5]
self.survival = [4, 5]
elif rule == "5766":
self.birth = [5]
self.survival = [7, 6]
else:
self.birth = [5]
self.survival = [4, 5]
# Ядро для подсчёта соседей (3x3x3 куб)
self.kernel = np.ones((3, 3, 3), dtype=int)
self.kernel[1, 1, 1] = 0 # Не считаем саму клетку
def compute( self, grid ):
neighbors = convolve(grid.astype(int), self.kernel, mode='constant', cval=0)
# Применяем правила
new_grid = np.zeros_like(grid)
# Рождение новых клеток
for n in self.birth:
new_grid |= (neighbors == n) & ~grid
# Выживание существующих
for n in self.survival:
new_grid |= (neighbors == n) & grid
grid = new_grid
return [grid]
# выгружает грани
class export_halo:
def __init__(self,S=1): # S радиус
self.SIZE=S
# idea мб выгружать все грани в массив 1 и все же их рассылать
def compute( self, grid):
S = self.SIZE
faces = {
'sx_first': grid[S, :, :].copy(), # первая плоскость по оси 0
'sx_last': grid[-S, :, :].copy(), # последняя плоскость по оси 0
'sy_first': grid[:, S, :].copy(), # первая плоскость по оси 1
'sy_last': grid[:, -S, :].copy(), # последняя плоскость по оси 1
'sz_first': grid[:, :, S].copy(), # первая плоскость по оси 2
'sz_last': grid[:, :, -S].copy() # последняя плоскость по оси 2
}
#return [faces]
return [faces['sx_first'],faces['sx_last'],faces['sy_first'],faces['sy_last'],faces['sz_first'],faces['sz_last']]
# загружает грани
class import_halo:
def __init__(self,S=1): # S радиус
self.SIZE=1
# idea мб выгружать все грани в массив 1 и все же их рассылать
def compute( self, grid, sx_first,sx_last,sy_first,sy_last,sz_first,sz_last):
S = self.SIZE
if len(sx_first) > 0:
grid[S, :, :] = sx_first
if len(sx_last) > 0:
grid[-S, :, :] = sx_last
if len(sy_first) > 0:
grid[:, S, :] = sy_first
if len(sy_last) > 0:
grid[:, -S, :] = sy_last
if len(sz_first) > 0:
grid[:, :, S] = sz_first
if len(sz_last) > 0:
grid[:, :, -S] = sz_last
return [grid]
# создание блоков гало-данных
def generate_halo_data(nodes,shape):
idx = 0
EE = [] # значение для граничных граней
def getnode(nx,ny,nz):
return nodes[nz + ny*shape[2] + nx*shape[2]*shape[1]]
for nx in range(shape[0]):
for ny in range(shape[1]):
for nz in range(shape[2]):
n = nodes[idx]
idx += 1
# x
d = par.data()
n.add_data("sx_first_out",d)
if nx > 0:
neib = getnode(nx-1,ny,nz)
neib.add_data("sx_last_in",d.copy())
else:
n.add_data("sx_first_in",par.data().const().put(EE))
d = par.data()
n.add_data("sx_last_out",d)
if nx < shape[0]-1:
neib = getnode(nx+1,ny,nz)
neib.add_data("sx_first_in",d.copy())
else:
n.add_data("sx_last_in",par.data().const().put(EE))
# y
d = par.data()
n.add_data("sy_first_out",d)
if ny > 0:
neib = getnode(nx,ny-1,nz)
neib.add_data("sy_last_in",d.copy())
else:
n.add_data("sy_first_in",par.data().const().put(EE))
d = par.data()
n.add_data("sy_last_out",d)
if ny < shape[1]-1:
neib = getnode(nx,ny+1,nz)
neib.add_data("sy_first_in",d.copy())
else:
n.add_data("sy_last_in",par.data().const().put(EE))
# z
d = par.data()
n.add_data("sz_first_out",d)
if nz > 0:
neib = getnode(nx,ny,nz-1)
neib.add_data("sz_last_in",d.copy())
else:
n.add_data("sz_first_in",par.data().const().put(EE))
d = par.data()
n.add_data("sz_last_out",d)
if nz < shape[2]-1:
neib = getnode(nx,ny,nz+1)
neib.add_data("sz_first_in",d.copy())
else:
n.add_data("sz_last_in",par.data().const().put(EE))
# создание основных узлов и блоков данных
def generate_life_nodes(shape,workers_count):
nodes = []
idx = 0
for nx in range(shape[0]):
for ny in range(shape[1]):
for nz in range(shape[2]):
n = par.node().set_name(f"node_{nx:02d}_{ny:02d}_{nz:02d}")
#n.add_data("cell",par.data().put(np.array(())))
n.add_data("cell",par.data().put(1))
n.add_data("cell_computed",par.data().put([]))
n.worker( idx % workers_count )
n.add_data("shape",par.data().put(shape).const())
n.add_data("pos",par.data().put([nx,ny,nz]).const())
# todo это надо уметь в контексте правила добавлять
# т.е. идея что правило не только вычисляет а и блоки данных добавляет
# это вполне себе плагинно
n.add_data("rgb",par.data())
n.add_data("depth",par.data())
idx += 1
nodes.append(n)
return nodes
class pcounter:
def __init__(self):
self.val = 0
pass
def compute( self, a ):
self.val += 1
print("pcounter val=",self.val)
return [self.val]
class printer:
def __init__(self,prefix):
self.prefix=prefix
pass
def compute( self, *a ):
print(self.prefix,*a)
class saver:
def __init__(self,prefix,filter_node=None):
self.prefix=prefix
self.filter_node=filter_node
pass
def compute( self, arr):
#fn = self.prefix
# встроенный фильтр
if self.filter_node is not None and self.node.name != self.filter_node:
return []
fn = f"{self.prefix}-{self.iter_num:05d}-{self.node.name}"
#mode = "w" if self.PROCID == 0 else "a"
#print("writing to file",fn,"mode",mode,"arr=",arr,flush=True)
mode = "w"
with open(fn,mode) as f:
print(arr,file=f)
#for i in range(len(arr)):
# f.write(f"{arr[i]:.2f} ")
#f.write("\n") # пусть так виднее будет
#if self.PROCID == 0:
# np.savetxt( f,arr,fmt="%f",delimiter="\t",footer="\n" )
#else:
# np.savetxt( f,arr,fmt="%f",delimiter="\t",footer="\n",mode="a" )
return []
class image_saver:
def __init__(self,prefix,filter_node=None):
self.prefix=prefix
self.filter_node=filter_node
pass
def compute( self, rgb):
#fn = self.prefix
# встроенный фильтр
if self.filter_node is not None and self.node.name != self.filter_node:
return []
fn = f"{self.prefix}-{self.iter_num:05d}-{self.node.name}.png"
imageio.imwrite(fn, rgb)
# онлайн вариант todo это надо отдельным правилом
fn = f"{self.prefix}-online.png"
imageio.imwrite(fn, rgb)
return []
##########################
g = par.graph()
###### узлы данных
#NODES_SHAPE = [2,2,2]
NODES_SHAPE = [8,4,4]
life_nodes = generate_life_nodes(NODES_SHAPE,NPROCS)
g.add_nodes( life_nodes )
generate_halo_data( life_nodes, NODES_SHAPE )
###### инициализация
r = par.rule().input("cell",always=True).output("cell").code( random_voxels, 10,0.2 ).limit(1)
g.add_rule( r )
###### основной расчет
r = par.rule().input("cell").output("cell_computed").code( game_of_life3d ).offset(1)
g.add_rule( r )
###### обмен гранями
# выгрузка
r = par.rule().input("cell_computed").output("sx_first_out","sx_last_out","sy_first_out","sy_last_out","sz_first_out","sz_last_out").code( export_halo ).offset(1)
g.add_rule( r )
# загрузка
r = par.rule().input("cell_computed","sx_first_in","sx_last_in","sy_first_in","sy_last_in","sz_first_in","sz_last_in").output("cell").code( import_halo ).offset(1)
g.add_rule( r )
############# сохранение и печать
# todo если процесс не производит то как бы и не надо чтобы он влиял на счетчик успешных правил
r = par.rule().input("cell").code( printer,"======== ======== ======== CURVAL" )
# g.add_rule( r )
#r = par.rule().input("cell").code( saver,f"{OUTPUT_DIR}/life","node_00_00_00" ).every(1)
#g.add_rule( r )
# рисование
r = par.rule().input("cell","pos","shape").output("rgb","depth").code( render_voxels ).every(1).offset(1)
g.add_rule( r )
# рисование первой ячейки
#r = par.rule().input("rgb").code( image_saver,f"{OUTPUT_DIR}/life","node_00_00_00" ).every(1)
#g.add_rule( r )
# сбор пирамиды
def create_paint_pyramid(nodes):
# считается что из nodes выходит rgb, depth
# далее происходит сборка изображений отдельными узлами
level = 1
current_level = nodes
next_level = []
total_nodes = []
while len(current_level) > 1:
#print("level len",len(current_level))
for i in range(0,len(current_level),2):
print(i)
n1 = current_level[i]
n2 = current_level[i+1]
# сохдаем узел и прикручиваем его к рабочему на котором первые данные
next_node = par.node().worker( n1.worker_id ).set_name(f"merger_level_{level}_{i}")
# вход
next_node.add_data( "rgb1", n1.edges["rgb"].copy() )
next_node.add_data( "depth1", n1.edges["depth"].copy() )
next_node.add_data( "rgb2", n2.edges["rgb"].copy() )
next_node.add_data( "depth2", n2.edges["depth"].copy() )
# результат
next_node.add_data( "rgb", par.data() )
next_node.add_data( "depth", par.data() )
next_level.append(next_node)
total_nodes.append(next_node)
current_level = next_level
next_level = []
level += 1
current_level[0].add_data("final_rgb",current_level[0].edges["rgb"].copy() )
#print("total_nodes=",len(total_nodes))
return total_nodes
painting_nodes = create_paint_pyramid( life_nodes )
g.add_nodes( painting_nodes )
r = par.rule().input("rgb1","depth1","rgb2","depth2").output("rgb","depth").code( merge_images ).every(1).offset(1)
g.add_rule( r )
r = par.rule().input("final_rgb").code( image_saver,f"{OUTPUT_DIR}/life" ).every(1).offset(1)
g.add_rule( r )
print("graph complete",flush=True)
print(json.dumps(g,cls=par.json_encoder))
runner = ppkrunner.runner(NPROCS,PROCID,FIRST_NODE)
with runner.start():
runner.run( g,50 )
print("all finished",flush=True)
\ Нет новой строки в конце файла
Поддерживает Markdown
0% или .
You are about to add 0 people to the discussion. Proceed with caution.
Сначала завершите редактирование этого сообщения!
Пожалуйста, зарегистрируйтесь или чтобы прокомментировать