| """
|
| OpenFOAM 数据加载模块
|
| ----------------------
|
| 实现 Dataset 和 DataLoader 类，用于将 OpenFOAM 仿真数据转换为结构化张量，供神经网络训练使用。（另有可视化静态方法）
|
|
|
| DATASET 输出 (单个样本)
|
| fields_list = [field_dict_t0, field_dict_t1, ..., field_dict_t{S-1}] # S = number_of_steps_to_get
|
| field_dict_tk = {
|
| 'Ux' : (Ny, Nx)
|
| 'Uy' : (Ny, Nx)
|
| 'p' : (Ny, Nx)
|
| 'xGrid': (Ny, Nx)
|
| 'yGrid': (Ny, Nx)
|
| 'mask' : (Ny, Nx)
|
| }
|
| infos_list = [info_dict_t0, info_dict_t1, ..., info_dict_t{S-1}]
|
| info_dict_tk = {
|
| 'dt' : float
|
| 'dt_simulation': float
|
| 'time' : float
|
| 'fluid' : { 'rho': float, 'mu': float, 'nu': float, 'Re': float }
|
| 'geometry' : { 'structure_length_y': float,
|
| 'structure_length_x': float,
|
| 'bbox': (4,) }
|
| 'solid_velocity': (vector_dim,)
|
| 'boundary' : dict
|
| }
|
|
|
| DataLoader 批次输出（同名变量）
|
| fields_seq = [batch_field_dict_t0, batch_field_dict_t1, ..., batch_field_dict_t{S-1}]
|
| batch_field_dict_tk = {
|
| key: torch.Tensor (B, C, Ny, Nx) # C=1 for scalar fields
|
| } # 张量位于 Dataset 指定的 device，上层代码可直接送入 CNN
|
| infos_seq = [batch_info_dict_t0, batch_info_dict_t1, ..., batch_info_dict_t{S-1}]
|
| batch_info_dict_tk = {
|
| 'dt' : torch.Tensor (B, 1) 设备 = Dataset 指定 device
|
| 'dt_simulation': torch.Tensor (B, 1) 设备 = CPU
|
| 'time' : torch.Tensor (B, 1) 设备 = CPU
|
| 'fluid' : { 同名键 -> torch.Tensor (B, 1) 设备 = CPU }
|
| 'geometry' : { 'bbox': torch.Tensor (B, 4),
|
| 其它键 -> torch.Tensor (B, 1) 设备 = CPU }
|
| 'solid_velocity': torch.Tensor (B, vector_dim) 设备 = CPU
|
| 'boundary' : list[dict] (dict 保留 Dataset 一致的原始结构)
|
| }
|
|
|
| NOTE
|
| 场的张量的维度：(B, C, H or Ny, W or Nx)
|
| dataloader/dataset给的是一个列表，每个元素是一个时间步的数据（所需的时间步数由属性self._number_of_steps_to_get控制）
|
| 场的张量数据的i方向(H)和j方向(W)分别对应物理场的-y和x方向
|
| bbox的格式为(xmin,ymin,xmax,ymax)
|
| Re = rho*v*d/mu = v*d/nu
|
| 注意p在OpenFOAM场文件中的单位是m^2/s^2(即此处实则为p/rho)
|
| 推荐使用: create_dataloader_cat (ConcatDatasetsWrapper), 可以同时加载多个数据集并作为一个整体进行训练
|
|
|
| TODO
|
| 流线图获取方法（参考phiflow库的stream lines绘制，如from phi.vis import plot）
|
|
|
| """
|
|
|
| import os
|
| import re
|
| import shutil
|
| import numpy as np
|
| import warnings
|
| import random
|
| from collections.abc import Sequence
|
| try:
|
| import torch
|
| from torch.utils.data import Dataset, DataLoader
|
| HAVE_TORCH = True
|
| except Exception:
|
| torch = None
|
| HAVE_TORCH = False
|
|
|
| class Dataset(object):
|
| pass
|
| class DataLoader(object):
|
| pass
|
| import matplotlib.pyplot as plt
|
| from matplotlib.collections import LineCollection
|
| from matplotlib.colors import Normalize
|
| import subprocess
|
| try:
|
| from scipy.interpolate import RegularGridInterpolator
|
| HAVE_SCIPY_INTERP = True
|
| except Exception:
|
| RegularGridInterpolator = None
|
| HAVE_SCIPY_INTERP = False
|
|
|
|
|
| def _to_numpy(array):
|
| if HAVE_TORCH and isinstance(array, torch.Tensor):
|
| return array.detach().cpu().numpy()
|
| return np.asarray(array)
|
|
|
|
|
| class OpenfoamDataset(Dataset):
|
| def __init__(self, root_dir, number_of_steps_to_get=2,
|
| vector_field='U', scalar_field='p',
|
| vector_dim=2, vector_keep_dims=None,
|
| device='cpu',
|
| dtype=None, coord_digits=8):
|
| """
|
| root_dir: OpenFOAM case 目录（包含 0, 1, 2... 等时间步文件夹）
|
| number_of_steps_to_get: 每个样本连续采样的时间步数量（默认 2）
|
| vector_field: 速度场名（如 'U'）
|
| scalar_field: 压力场名（如 'p'）
|
| vector_dim: 速度场维度（2 或 3）
|
| vector_keep_dims: 需要保留的速度分量索引列表，例如 ``[0, 1]`` 表示仅取 x/y 分量，``None`` 时默认取 ``range(min(2, vector_dim))``
|
| device: torch 设备
|
| dtype: torch 数据类型
|
| coord_digits: 构建结构化网格时对坐标取 round 的小数位数，避免由浮点误差导致的索引错配
|
| """
|
|
|
| self.n_fluid_points = 0
|
| self.n_time_steps = 0
|
|
|
| self.root_dir = root_dir
|
| self._number_of_steps_to_get = number_of_steps_to_get
|
| self.vector_field = vector_field
|
| self.scalar_field = scalar_field
|
| self.vector_dim = vector_dim
|
|
|
| if vector_keep_dims is None:
|
| self.vector_keep_dims = list(range(min(2, vector_dim)))
|
| else:
|
| self.vector_keep_dims = list(vector_keep_dims)
|
| self.device = device
|
|
|
| if HAVE_TORCH:
|
| self.dtype = dtype if dtype is not None else torch.float32
|
| else:
|
| self.dtype = None
|
|
|
| self.coord_digits = coord_digits
|
| self.time_dirs = self._find_time_dirs()
|
| self.fluid_info = self._load_fluid_info()
|
|
|
| self.grid_points, self.Nx, self.Ny, self.xs, self.ys = self._load_structured_grid()
|
|
|
| try:
|
| self.n_fluid_points = int(self.Nx * self.Ny)
|
| except Exception:
|
| self.n_fluid_points = 0
|
| self.n_time_steps = len(self.time_dirs)
|
|
|
|
|
| if self._number_of_steps_to_get <= 0:
|
| raise ValueError('number_of_steps_to_get must be a positive integer.')
|
| if self.__len__() <= 0:
|
| raise ValueError('Dataset is empty, or number_of_steps_to_get is larger than available time steps.')
|
|
|
| def _find_time_dirs(self):
|
|
|
| dirs = [d for d in os.listdir(self.root_dir) if d.isdigit()]
|
| if not dirs:
|
|
|
| return ['.']
|
| dirs = sorted(dirs, key=lambda x: float(x))
|
| return dirs
|
|
|
| def _load_structured_grid(self):
|
|
|
| first_time = self._find_time_dirs()[0]
|
| if first_time == '.':
|
| c_path = os.path.join(self.root_dir, 'C')
|
| else:
|
| c_path = os.path.join(self.root_dir, first_time, 'C')
|
|
|
|
|
| declared_n = self._parse_internal_list_count(c_path) or 0
|
| if declared_n > 0:
|
| self.n_fluid_points = int(declared_n)
|
| c_arr = np.array(self._read_field(c_path, vector=True))
|
|
|
| if c_arr.ndim == 1:
|
| c_arr = c_arr.reshape(-1, 1)
|
| if c_arr.shape[1] >= max(self.vector_keep_dims) + 1:
|
| c_arr = c_arr[:, self.vector_keep_dims]
|
|
|
| if c_arr.shape[1] >= 2:
|
| c_arr = c_arr[:, :2]
|
| xs = np.unique(np.round(c_arr[:,0], self.coord_digits))
|
| ys = np.unique(np.round(c_arr[:,1], self.coord_digits))
|
|
|
|
|
| ys_desc = ys[::-1]
|
| Nx = len(ys_desc)
|
| Ny = len(xs)
|
|
|
| grid_points = np.zeros((Nx, Ny, 2))
|
| for i, y in enumerate(ys_desc):
|
| for j, x in enumerate(xs):
|
| grid_points[i, j, 0] = x
|
| grid_points[i, j, 1] = y
|
|
|
| return grid_points, Nx, Ny, xs, ys
|
|
|
| def _parse_internal_list_count(self, path):
|
|
|
| if not os.path.exists(path):
|
| return None
|
| with open(path, 'r') as f:
|
| txt = f.read()
|
| m = re.search(r'internalField\s+nonuniform\s+List<[^>]+>\s+(\d+)', txt)
|
| if m:
|
| return int(m.group(1))
|
| return None
|
|
|
| def _read_field(self, path, vector=True):
|
| """
|
| 解析 OpenFOAM 字段文件的 internalField 区块。
|
| 支持 nonuniform List<vector|scalar> 和 uniform(...)
|
| 返回 numpy 数组：vector -> (N, k), scalar -> (N,)
|
| 若 header 中声明的数量与实际解析行数不一致，会抛出 RuntimeError。
|
| """
|
| if not os.path.exists(path):
|
| raise FileNotFoundError(f"未找到字段文件: {path}")
|
| with open(path, 'r') as f:
|
| content = f.read()
|
|
|
|
|
| m_head = re.search(r'internalField\s+nonuniform\s+List<(vector|scalar)>\s*(\d+)', content)
|
| if m_head:
|
| ftype = m_head.group(1)
|
| n_decl = int(m_head.group(2))
|
|
|
|
|
| m_block = re.search(r"\(\s*\n(.*?)\n\s*\)\s*;", content[m_head.end():], re.DOTALL | re.MULTILINE)
|
| if not m_block:
|
|
|
| start_pos = content.find('(', m_head.end())
|
| if start_pos == -1:
|
| raise ValueError(f"无法解析 nonuniform List 块（缺失 '('）: {path}")
|
|
|
|
|
| rel = content[m_head.end():]
|
| m_end = re.search(r"\n\s*\)\s*;", rel)
|
| if m_end:
|
| end_pos = m_head.end() + m_end.start()
|
| block = content[start_pos+1:end_pos].strip()
|
| else:
|
|
|
| end_pos = content.rfind(')')
|
| if end_pos == -1:
|
| raise ValueError(f"无法解析 nonuniform List 块（缺失 ')'）: {path}")
|
| block = content[start_pos+1:end_pos].strip()
|
| else:
|
| block = m_block.group(1).strip()
|
| lines = [ln.strip() for ln in block.splitlines() if ln.strip()]
|
| if len(lines) != n_decl:
|
|
|
| warnings.warn(f"文件 {os.path.basename(path)} 声明 {n_decl} 个 internalField 条目，但解析到 {len(lines)} 行。将以解析到的 {len(lines)} 行为准。", RuntimeWarning)
|
| if ftype == 'vector':
|
| arr = []
|
| for ln in lines:
|
| nums = re.findall(r'[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?', ln)
|
| arr.append([float(x) for x in nums])
|
| arr = np.array(arr)
|
|
|
| if arr.ndim == 2 and len(self.vector_keep_dims) > 0:
|
| max_idx = max(self.vector_keep_dims)
|
| if arr.shape[1] > max_idx:
|
| arr = arr[:, self.vector_keep_dims]
|
|
|
| return arr
|
| else:
|
| vals = []
|
| for ln in lines:
|
| m = re.search(r'[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?', ln)
|
| vals.append(float(m.group(0)) if m else 0.0)
|
| return np.array(vals)
|
|
|
|
|
| m_uni = re.search(r'internalField\s+uniform\s*(.*?);', content, re.DOTALL)
|
| if m_uni:
|
| token = m_uni.group(1).strip()
|
|
|
| if token.startswith('(') and token.endswith(')'):
|
| inner = token[1:-1].strip()
|
| items = inner.split()
|
| else:
|
| items = token.split()
|
| nums = []
|
| for it in items:
|
| try:
|
| nums.append(float(it))
|
| except Exception:
|
|
|
| pass
|
|
|
| first_time = self.time_dirs[0]
|
| if first_time == '.':
|
| c_path = os.path.join(self.root_dir, 'C')
|
| else:
|
| c_path = os.path.join(self.root_dir, first_time, 'C')
|
| npts = self._parse_internal_list_count(c_path) or 1
|
| if vector:
|
| vec = np.array(nums)
|
| if vec.size == 0:
|
| vec = np.zeros((1,))
|
|
|
| if len(vec) > 0 and len(self.vector_keep_dims) > 0:
|
| max_idx = max(self.vector_keep_dims)
|
| if vec.size > max_idx:
|
| vec = vec[self.vector_keep_dims]
|
| arr = np.tile(vec.reshape(1, -1), (npts, 1))
|
| return arr
|
| else:
|
| val = nums[0] if len(nums) > 0 else 0.0
|
| return np.full((npts,), val)
|
|
|
| raise ValueError(f"无法解析 internalField: {path}")
|
|
|
| def _load_fluid_info(self):
|
|
|
|
|
| rho, mu, nu = 1.0, None, None
|
| Re_val = None
|
|
|
| files = []
|
| for dname in ['constant', 'system', '']:
|
| dpath = os.path.join(self.root_dir, dname) if dname else self.root_dir
|
| if os.path.exists(dpath) and os.path.isdir(dpath):
|
| tp = os.path.join(dpath, 'transportProperties')
|
| if os.path.exists(tp) and os.path.isfile(tp):
|
| files.append(tp)
|
|
|
| for fname in os.listdir(dpath):
|
| p = os.path.join(dpath, fname)
|
| if os.path.isfile(p) and p not in files:
|
| files.append(p)
|
|
|
| for p in files:
|
| try:
|
| txt = open(p, 'r', encoding='utf-8', errors='ignore').read()
|
| except Exception:
|
| continue
|
|
|
| m_re = re.search(r'\bRe_blockage\b\s*(?:=|:)\s*([0-9eE+\-.]+)', txt)
|
| if not m_re:
|
| m_re = re.search(r'\bRe\b\s*(?:=|:)\s*([0-9eE+\-.]+)', txt)
|
| if m_re:
|
| try:
|
| Re_val = float(m_re.group(1))
|
| except Exception:
|
| Re_val = None
|
|
|
| m_nu = re.search(r'\bnu\b\s*(?:\[.*?\])?\s*([0-9eE+\-.]+)', txt)
|
| if not m_nu:
|
| m_nu = re.search(r'kinematicViscosity\s*([0-9eE+\-.]+)', txt)
|
| if m_nu:
|
| try:
|
| nu = float(m_nu.group(1))
|
| except Exception:
|
| nu = None
|
|
|
| m_mu = re.search(r'\bmu\b\s*(?:[\[\(].*?[\]\)])?\s*([0-9eE+\-.]+)', txt)
|
| if m_mu:
|
| try:
|
| mu = float(m_mu.group(1))
|
| except Exception:
|
| pass
|
| m_rho = re.search(r'\brho\b\s*(?:[\[\(].*?[\]\)])?\s*([0-9eE+\-.]+)', txt)
|
| if m_rho:
|
| try:
|
| rho = float(m_rho.group(1))
|
| except Exception:
|
| pass
|
|
|
| if rho is None:
|
| rho = 1.0
|
| if mu is None:
|
|
|
| try:
|
| mu = float(rho) * float(nu)
|
| except Exception:
|
| mu = 1.0
|
| if nu is None:
|
|
|
| try:
|
| nu = float(mu) / float(rho) if rho != 0 else 1.0
|
| except Exception:
|
| nu = 1.0
|
|
|
| info = {'rho': rho, 'mu': mu, 'nu': nu}
|
|
|
| if Re_val is not None:
|
| try:
|
| info['Re'] = float(Re_val)
|
| except Exception:
|
| info['Re'] = None
|
| else:
|
| info['Re'] = None
|
| return info
|
|
|
| def parse_solid_velocity(self, *args, **kwargs):
|
| """占位函数：未来用于解析固体速度，目前返回全零（自适应维度）。"""
|
| return tuple([0.0] * self.vector_dim)
|
|
|
| def _parse_inlet_velocity(self, u_path):
|
| """尝试从 U 文件的 boundaryField 中解析 inlet 的 value（向量）。返回 None 或长度为 self.vector_dim 的 tuple。"""
|
| if not os.path.exists(u_path):
|
| return None
|
| try:
|
| txt = open(u_path, 'r', encoding='utf-8', errors='ignore').read()
|
| except Exception:
|
| return None
|
|
|
| def _extract_brace_block(s, start_idx):
|
|
|
| depth = 0
|
| for i in range(start_idx, len(s)):
|
| if s[i] == '{':
|
| depth += 1
|
| elif s[i] == '}':
|
| depth -= 1
|
| if depth == 0:
|
| return s[start_idx+1:i], i
|
| return None, None
|
|
|
| m_bf = re.search(r'boundaryField\s*\{', txt)
|
| if not m_bf:
|
| return None
|
| bf_start = m_bf.end() - 1
|
| bf_block, bf_end = _extract_brace_block(txt, bf_start)
|
| if bf_block is None:
|
| return None
|
|
|
|
|
|
|
| inlet_block = None
|
| for m in re.finditer(r'([A-Za-z0-9_\-]+)\s*\{', bf_block):
|
| name = m.group(1)
|
|
|
| if 'inlet' in name.lower():
|
| global_pos = bf_start + 1 + m.start()
|
| brace_pos = txt.find('{', global_pos)
|
| if brace_pos != -1:
|
| blk, _ = _extract_brace_block(txt, brace_pos)
|
| inlet_block = blk
|
| break
|
| if inlet_block is None:
|
|
|
| m_any = re.search(r'([A-Za-z0-9_\-]+)\s*\{', bf_block)
|
| if m_any:
|
| global_pos = bf_start + 1 + m_any.start()
|
| brace_pos = txt.find('{', global_pos)
|
| if brace_pos != -1:
|
| blk, _ = _extract_brace_block(txt, brace_pos)
|
| inlet_block = blk
|
| if not inlet_block:
|
| return None
|
|
|
|
|
| m_val = re.search(r'value\s+(?:uniform\s*)?\(?\s*([\-+0-9eE\.\s]+)\s*\)?\s*;', inlet_block)
|
| if not m_val:
|
| return None
|
| nums = re.findall(r'[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?', m_val.group(1))
|
| try:
|
| vals = [float(x) for x in nums]
|
| if len(vals) < self.vector_dim:
|
| vals += [0.0] * (self.vector_dim - len(vals))
|
|
|
| return {'value': tuple(vals[:self.vector_dim])}
|
| except Exception:
|
| return None
|
|
|
| def _compute_structure_length(self, mask, xGrid, yGrid):
|
| """基于固体掩码计算结构物的纵向长度：掩码中 0 表示固体、1 表示流体。
|
| 返回沿 y 方向的跨度（也返回 x/y 的 bbox）。若没有固体则返回 0。
|
| 说明：这里假设 "纵向" 是垂直方向（y）；如需改为流向，请告知。
|
| """
|
| try:
|
| arr_mask = np.asarray(mask)
|
| if arr_mask.dtype == bool:
|
| solid_mask = ~arr_mask
|
| else:
|
| solid_mask = arr_mask < 0.5
|
|
|
| if not np.any(solid_mask):
|
| return 0.0, 0.0, None
|
|
|
| x_coords = np.asarray(xGrid)[solid_mask]
|
| y_coords = np.asarray(yGrid)[solid_mask]
|
| if x_coords.size == 0 or y_coords.size == 0:
|
| return 0.0, 0.0, None
|
|
|
| xmin = float(np.min(x_coords))
|
| xmax = float(np.max(x_coords))
|
| ymin = float(np.min(y_coords))
|
| ymax = float(np.max(y_coords))
|
|
|
| x_span = float(xmax - xmin)
|
| y_span = float(ymax - ymin)
|
|
|
| bbox = (xmin, ymin, xmax, ymax)
|
| return y_span, x_span, bbox
|
| except Exception:
|
| return 0.0, 0.0, None
|
|
|
| def _get_dt(self, case_dir):
|
| """
|
| 尝试读取 case 的 system/controlDict 中的 deltaT；若未找到则返回默认 1.0
|
| """
|
|
|
| candidates = [os.path.join(self.root_dir, 'system', 'controlDict'),
|
| os.path.join(case_dir, 'system', 'controlDict'),
|
| os.path.join(case_dir, 'uniform', 'time'),
|
| os.path.join(case_dir, 'time')]
|
| for p in candidates:
|
| if os.path.exists(p):
|
| try:
|
| with open(p, 'r') as f:
|
| txt = f.read()
|
| m = re.search(r'deltaT\s+([0-9eE+\-.]+)', txt)
|
| if m:
|
| return float(m.group(1))
|
| except Exception:
|
| pass
|
| return 1.0
|
|
|
| def _get_write_interval(self, case_dir):
|
| """
|
| 尝试从 controlDict 中解析 writeInterval 的值；若未找到返回 None
|
| """
|
| candidates = [os.path.join(self.root_dir, 'system', 'controlDict'),
|
| os.path.join(case_dir, 'system', 'controlDict')]
|
| for p in candidates:
|
| if os.path.exists(p):
|
| try:
|
| with open(p, 'r') as f:
|
| txt = f.read()
|
| m = re.search(r'writeInterval\s+([0-9eE+\-.]+)', txt)
|
| if m:
|
| try:
|
| return float(m.group(1))
|
| except Exception:
|
| return None
|
| except Exception:
|
| pass
|
| return None
|
|
|
| def _get_time_value(self, case_dir):
|
| """读取当前时间步下的 uniform/time 文件以获取 value（物理时间）。"""
|
| candidates = [os.path.join(case_dir, 'uniform', 'time'), os.path.join(case_dir, 'time'), os.path.join(case_dir, 'uniform', 'timeFile')]
|
| for p in candidates:
|
| if os.path.exists(p):
|
| with open(p, 'r') as f:
|
| txt = f.read()
|
| m = re.search(r'value\s+([0-9eE+\-.]+)', txt)
|
| if m:
|
| try:
|
| return float(m.group(1))
|
| except Exception:
|
| pass
|
|
|
| try:
|
| return float(os.path.basename(case_dir))
|
| except Exception:
|
| return 0.0
|
|
|
| def __len__(self):
|
| total_frames = len(self.time_dirs)
|
| window = max(int(self._number_of_steps_to_get), 1)
|
| if total_frames == 0 or window > total_frames:
|
| return 0
|
| return total_frames - window + 1
|
|
|
| def _get_one_frame(self, idx):
|
|
|
| time_dir = self.time_dirs[idx]
|
| if time_dir == '.':
|
| case_dir = self.root_dir
|
| else:
|
| case_dir = os.path.join(self.root_dir, time_dir)
|
|
|
| c_path = os.path.join(case_dir, 'C')
|
| U_path = os.path.join(case_dir, self.vector_field)
|
| p_path = os.path.join(case_dir, self.scalar_field)
|
|
|
|
|
| point_list = np.array(self._read_field(c_path, vector=True))
|
| if point_list.ndim == 1:
|
| point_list = point_list.reshape(-1, 1)
|
|
|
| if point_list.shape[1] > max(self.vector_keep_dims):
|
| point_list = point_list[:, self.vector_keep_dims]
|
| if point_list.shape[1] >= 2:
|
| point_list = point_list[:, :2]
|
|
|
|
|
| U = np.array(self._read_field(U_path, vector=True))
|
| p = np.array(self._read_field(p_path, vector=False))
|
|
|
|
|
| n_pts = point_list.shape[0]
|
|
|
| try:
|
| declared_n = self._parse_internal_list_count(c_path)
|
| if declared_n and declared_n > 0:
|
|
|
| self.n_fluid_points = declared_n
|
| if declared_n != n_pts:
|
| raise RuntimeError(f"C 文件声明 {declared_n} 个 internalField 条目，但解析到 {n_pts} 行。请检查解析器或文件格式。")
|
| except FileNotFoundError:
|
|
|
| pass
|
| if U.shape[0] != n_pts:
|
| raise RuntimeError(f"点数不匹配: C 中 {n_pts} 个点, 但 {self.vector_field} 中 {U.shape[0]} 个点")
|
| if p.shape[0] != n_pts:
|
| raise RuntimeError(f"点数不匹配: C 中 {n_pts} 个点, 但 {self.scalar_field} 中 {p.shape[0]} 个点")
|
|
|
|
|
| xs = np.unique(np.round(point_list[:, 0], self.coord_digits))
|
| ys = np.unique(np.round(point_list[:, 1], self.coord_digits))
|
|
|
| ys_desc = ys[::-1]
|
| Nx = len(ys_desc)
|
| Ny = len(xs)
|
|
|
| xGrid = np.zeros((Nx, Ny), dtype=float)
|
| yGrid = np.zeros((Nx, Ny), dtype=float)
|
| for i, y in enumerate(ys_desc):
|
| for j, x in enumerate(xs):
|
| xGrid[i, j] = x
|
| yGrid[i, j] = y
|
|
|
|
|
| idx_map = {(round(x, self.coord_digits), round(y, self.coord_digits)): (i, j)
|
| for i, y in enumerate(ys_desc) for j, x in enumerate(xs)}
|
|
|
|
|
| Ux = np.zeros((Nx, Ny), dtype=float)
|
| Uy = np.zeros((Nx, Ny), dtype=float)
|
| p_grid = np.zeros((Nx, Ny), dtype=float)
|
| solid_mask = np.zeros((Nx, Ny), dtype=bool)
|
|
|
|
|
| fluid_points = {}
|
| fluid_grid_to_pt = {}
|
| for k, (x, y) in enumerate(point_list):
|
| key = (round(float(x), self.coord_digits), round(float(y), self.coord_digits))
|
| if key in idx_map:
|
| i, j = idx_map[key]
|
| fluid_points[k] = (i, j)
|
| fluid_grid_to_pt[(i, j)] = k
|
|
|
| if U.ndim == 1:
|
| Ux[i, j] = float(U[k])
|
| Uy[i, j] = 0.0
|
| else:
|
| if U.shape[1] > max(self.vector_keep_dims):
|
| uvals = U[k, self.vector_keep_dims]
|
| else:
|
| uvals = U[k, :len(self.vector_keep_dims)]
|
| Ux[i, j] = float(uvals[0])
|
| Uy[i, j] = float(uvals[1]) if len(uvals) > 1 else 0.0
|
| p_grid[i, j] = float(p[k])
|
| solid_mask[i, j] = True
|
|
|
|
|
| solid_points = [tuple(idx) for idx in np.argwhere(~solid_mask)]
|
|
|
|
|
| from scipy.spatial import cKDTree
|
| fluid_idx = np.array(list(fluid_grid_to_pt.keys())) if len(fluid_grid_to_pt) > 0 else np.zeros((0, 2), dtype=int)
|
| if fluid_idx.size > 0:
|
| tree = cKDTree(fluid_idx)
|
| solid_idx = np.argwhere(~solid_mask)
|
| for si in solid_idx:
|
| dist, nearest = tree.query(si)
|
| ni, nj = fluid_idx[nearest]
|
| p_grid[si[0], si[1]] = p_grid[ni, nj]
|
| Ux[si[0], si[1]] = 0.0
|
| Uy[si[0], si[1]] = 0.0
|
|
|
|
|
| def _to_tensor(arr):
|
|
|
| a = np.ascontiguousarray(np.asarray(arr))
|
| if HAVE_TORCH:
|
|
|
| t = torch.from_numpy(a).float().to(device=self.device)
|
| return t
|
| else:
|
| return a
|
|
|
| Ux = _to_tensor(Ux)
|
| Uy = _to_tensor(Uy)
|
| p_grid = _to_tensor(p_grid)
|
| xGrid_t = _to_tensor(xGrid)
|
| yGrid_t = _to_tensor(yGrid)
|
|
|
| fluid_mask = solid_mask.astype(np.float32)
|
| mask = _to_tensor(fluid_mask)
|
|
|
|
|
| solid_velocity = tuple([0.0] * self.vector_dim)
|
|
|
|
|
| inlet_info = self._parse_inlet_velocity(U_path)
|
|
|
| bc_info = {'inlet': inlet_info}
|
| inlet_side = None
|
| if inlet_info is not None and isinstance(inlet_info, dict):
|
| vals = inlet_info.get('value', None)
|
|
|
| inlet_side = 'x-'
|
| if vals is not None:
|
|
|
| if inlet_side == 'x-':
|
| j_idx = 0
|
| for i in range(Nx):
|
| Ux[i, j_idx] = float(vals[0]) if len(vals) > 0 else 0.0
|
| Uy[i, j_idx] = float(vals[1]) if len(vals) > 1 else 0.0
|
| elif inlet_side == 'x+':
|
| j_idx = Ny - 1
|
| for i in range(Nx):
|
| Ux[i, j_idx] = float(vals[0]) if len(vals) > 0 else 0.0
|
| Uy[i, j_idx] = float(vals[1]) if len(vals) > 1 else 0.0
|
| elif inlet_side == 'y+':
|
| i_idx = 0
|
| for j in range(Ny):
|
| Ux[i_idx, j] = float(vals[0]) if len(vals) > 0 else 0.0
|
| Uy[i_idx, j] = float(vals[1]) if len(vals) > 1 else 0.0
|
| elif inlet_side == 'y-':
|
| i_idx = Nx - 1
|
| for j in range(Ny):
|
| Ux[i_idx, j] = float(vals[0]) if len(vals) > 0 else 0.0
|
| Uy[i_idx, j] = float(vals[1]) if len(vals) > 1 else 0.0
|
|
|
|
|
| dt = self._get_dt(case_dir)
|
| write_interval = self._get_write_interval(case_dir)
|
| field = {'Ux': Ux, 'Uy': Uy, 'p': p_grid, 'xGrid': xGrid_t, 'yGrid': yGrid_t, 'mask': mask}
|
|
|
| time_value = self._get_time_value(case_dir)
|
|
|
| mask_np = None
|
| xGrid_np = None
|
| yGrid_np = None
|
| try:
|
| if HAVE_TORCH:
|
| mask_np = mask.detach().cpu().numpy()
|
| xGrid_np = xGrid_t.detach().cpu().numpy()
|
| yGrid_np = yGrid_t.detach().cpu().numpy()
|
| else:
|
| mask_np = np.asarray(mask)
|
| xGrid_np = np.asarray(xGrid_t)
|
| yGrid_np = np.asarray(yGrid_t)
|
| except Exception:
|
| pass
|
| if mask_np is None:
|
| mask_np = np.asarray(mask)
|
| if xGrid_np is None:
|
| xGrid_np = np.asarray(xGrid_t)
|
| if yGrid_np is None:
|
| yGrid_np = np.asarray(yGrid_t)
|
|
|
| try:
|
| length_y, length_x, bbox = self._compute_structure_length(mask_np, xGrid_np, yGrid_np)
|
| except Exception:
|
| length_y, length_x, bbox = 0.0, 0.0, None
|
|
|
|
|
| fluid_info = dict(self.fluid_info) if isinstance(self.fluid_info, dict) else {}
|
| info_dict = {
|
| 'dt': float(write_interval) if write_interval is not None else float(dt),
|
| 'dt_simulation': float(dt),
|
| 'time': float(time_value),
|
| 'fluid': fluid_info,
|
| 'geometry': None,
|
| 'solid_velocity': solid_velocity,
|
| 'boundary': bc_info
|
| }
|
|
|
|
|
| try:
|
| if fluid_info.get('Re') is None:
|
| nu = fluid_info.get('nu')
|
| if inlet_info is not None and nu and (length_y is not None) and nu != 0 and length_y > 0:
|
| vals = inlet_info.get('value', (0.0, 0.0)) if isinstance(inlet_info, dict) else (0.0, 0.0)
|
| u_in = float(np.sqrt(sum([float(x)**2 for x in vals[:self.vector_dim]])))
|
| Re_calc = u_in * float(length_y) / float(nu)
|
| fluid_info['Re'] = float(Re_calc)
|
| except Exception:
|
| pass
|
|
|
| geometry_data = {
|
| 'structure_length_y': float(length_y) if length_y is not None else 0.0,
|
| 'structure_length_x': float(length_x) if length_x is not None else 0.0,
|
| 'bbox': tuple(float(x) for x in bbox) if bbox is not None else None
|
| }
|
| info_dict['geometry'] = geometry_data
|
|
|
|
|
| try:
|
| info_dict['boundary']['inlet']['side'] = inlet_side
|
| except Exception:
|
| try:
|
| if isinstance(inlet_info, dict):
|
| inlet_info['side'] = inlet_side
|
| info_dict['boundary'] = {'inlet': inlet_info}
|
| except Exception:
|
| pass
|
|
|
| return field, info_dict
|
|
|
| def __getitem__(self, idx):
|
|
|
| total_available = len(self.time_dirs)
|
| window = int(self._number_of_steps_to_get)
|
| max_start = total_available - window
|
| if total_available == 0 or idx < 0 or idx > max_start:
|
| raise IndexError('index out of range for the configured number_of_steps_to_get.')
|
|
|
| fields_seq = []
|
| infos_seq = []
|
| for offset in range(window):
|
| field, info = self._get_one_frame(idx + offset)
|
| fields_seq.append(field)
|
| infos_seq.append(info)
|
|
|
| return fields_seq, infos_seq
|
|
|
| @staticmethod
|
| def _stack_field(values, *, device, dtype):
|
| if not values:
|
| return values
|
| if not HAVE_TORCH:
|
| arrays = [np.ascontiguousarray(np.asarray(v)) for v in values]
|
| stacked = np.stack(arrays, axis=0)
|
| if stacked.ndim == 3:
|
| stacked = stacked[:, None, ...]
|
| return stacked
|
|
|
| tensors = []
|
| target_dtype = dtype if dtype is not None else torch.float32
|
| target_device = device if device is not None else torch.device('cpu')
|
| for value in values:
|
| tensor = value if torch.is_tensor(value) else torch.as_tensor(value, dtype=target_dtype)
|
| tensor = tensor.to(device=target_device, dtype=target_dtype)
|
| if tensor.ndim == 2:
|
| tensor = tensor.unsqueeze(0)
|
| if tensor.ndim != 3:
|
| raise ValueError(f'Expected field tensor with 3 dims per sample (C, Ny, Nx); got {tuple(tensor.shape)}')
|
| tensors.append(tensor.contiguous())
|
| stacked = torch.stack(tensors, dim=0)
|
| return stacked.contiguous()
|
|
|
| @staticmethod
|
| def _collate_info(infos, *, batch_size, data_device):
|
| if not HAVE_TORCH:
|
| raise RuntimeError('torch is required for collating info dictionaries.')
|
|
|
| cpu_device = torch.device('cpu')
|
| info_list = [dict(info) if isinstance(info, dict) else {} for info in infos]
|
|
|
| def _collect_scalar(key, *, device, default=0.0):
|
| values = []
|
| for data in info_list:
|
| value = data.get(key, default)
|
| if value is None:
|
| value = default
|
| values.append(float(value))
|
| tensor = torch.tensor(values, dtype=torch.float32, device=device)
|
| return tensor.view(len(values), 1)
|
|
|
| info_out = {
|
| 'dt': _collect_scalar('dt', device=data_device, default=0.0),
|
| 'dt_simulation': _collect_scalar('dt_simulation', device=cpu_device, default=0.0),
|
| 'time': _collect_scalar('time', device=cpu_device, default=0.0),
|
| 'fluid': {},
|
| 'geometry': {},
|
| 'solid_velocity': None,
|
| 'boundary': []
|
| }
|
|
|
| fluid_keys = set()
|
| for data in info_list:
|
| fluid = data.get('fluid')
|
| if isinstance(fluid, dict):
|
| fluid_keys.update(fluid.keys())
|
| for key in sorted(fluid_keys):
|
| values = []
|
| for data in info_list:
|
| fluid = data.get('fluid') if isinstance(data.get('fluid'), dict) else {}
|
| value = fluid.get(key, 0.0) if isinstance(fluid, dict) else 0.0
|
| if value is None:
|
| value = 0.0
|
| values.append(float(value))
|
| tensor = torch.tensor(values, dtype=torch.float32, device=cpu_device)
|
| info_out['fluid'][key] = tensor.view(len(values), 1)
|
|
|
| geometry_keys = set()
|
| for data in info_list:
|
| geometry = data.get('geometry')
|
| if isinstance(geometry, dict):
|
| geometry_keys.update(geometry.keys())
|
|
|
| for key in sorted(geometry_keys):
|
| if key == 'bbox':
|
| bbox_vals = []
|
| for data in info_list:
|
| geometry = data.get('geometry') if isinstance(data.get('geometry'), dict) else {}
|
| bbox = geometry.get('bbox') if isinstance(geometry, dict) else None
|
| if bbox is None:
|
| bbox_vals.append([0.0, 0.0, 0.0, 0.0])
|
| else:
|
| bbox_vals.append([float(x) for x in bbox])
|
| info_out['geometry']['bbox'] = torch.tensor(bbox_vals, dtype=torch.float32, device=cpu_device)
|
| else:
|
| values = []
|
| for data in info_list:
|
| geometry = data.get('geometry') if isinstance(data.get('geometry'), dict) else {}
|
| value = geometry.get(key, 0.0) if isinstance(geometry, dict) else 0.0
|
| if value is None:
|
| value = 0.0
|
| values.append(float(value))
|
| tensor = torch.tensor(values, dtype=torch.float32, device=cpu_device)
|
| info_out['geometry'][key] = tensor.view(len(values), 1)
|
|
|
| solid_velocities = []
|
| max_dim = 0
|
| for data in info_list:
|
| vel = data.get('solid_velocity', ())
|
| vel_list = list(vel) if vel is not None else []
|
| max_dim = max(max_dim, len(vel_list))
|
| solid_velocities.append([float(x) for x in vel_list])
|
| if max_dim == 0:
|
| info_out['solid_velocity'] = torch.zeros((batch_size, 0), dtype=torch.float32, device=cpu_device)
|
| else:
|
| padded = []
|
| for vel in solid_velocities:
|
| vel = vel + [0.0] * (max_dim - len(vel))
|
| padded.append(vel)
|
| info_out['solid_velocity'] = torch.tensor(padded, dtype=torch.float32, device=cpu_device)
|
|
|
| info_out['boundary'] = [data.get('boundary') for data in info_list]
|
| return info_out
|
|
|
| @staticmethod
|
| def collate_fn(batch):
|
| if not batch:
|
| return [], []
|
|
|
| field_sequences, info_sequences = zip(*batch)
|
| steps = len(field_sequences[0]) if field_sequences else 0
|
|
|
| for seq in field_sequences:
|
| if len(seq) != steps:
|
| raise ValueError('All samples must contain the same number of frames.')
|
| for seq in info_sequences:
|
| if len(seq) != steps:
|
| raise ValueError('All samples must contain the same number of frames.')
|
|
|
| collated_fields = []
|
| collated_infos = []
|
|
|
| for step_idx in range(steps):
|
| step_fields = [seq[step_idx] for seq in field_sequences]
|
| step_infos = [seq[step_idx] for seq in info_sequences]
|
|
|
| data_device = None
|
| data_dtype = None
|
| if HAVE_TORCH:
|
| for sample in step_fields:
|
| for value in sample.values():
|
| if torch.is_tensor(value):
|
| data_device = value.device
|
| data_dtype = value.dtype
|
| break
|
| if data_device is not None:
|
| break
|
|
|
| first_field = step_fields[0]
|
| field_dict = {}
|
| for key in first_field.keys():
|
| values = [sample[key] for sample in step_fields]
|
| field_dict[key] = OpenfoamDataset._stack_field(values, device=data_device, dtype=data_dtype)
|
|
|
| if HAVE_TORCH:
|
| batch_size = len(step_fields)
|
| info_dict = OpenfoamDataset._collate_info(step_infos, batch_size=batch_size, data_device=data_device or torch.device('cpu'))
|
| else:
|
| info_dict = {}
|
|
|
| collated_fields.append(field_dict)
|
| collated_infos.append(info_dict)
|
|
|
| return collated_fields, collated_infos
|
|
|
| @staticmethod
|
| def plot_streamlines(field,
|
| ax=None,
|
| seed_density=0.6,
|
| seeds=None,
|
| step_size=None,
|
| max_steps=2000,
|
| min_speed=1e-5,
|
| color_mode='speed',
|
| cmap='viridis',
|
| linewidth=1.4,
|
| background='velocity',
|
| background_cmap='Greys',
|
| background_alpha=0.35,
|
| add_colorbar=True,
|
| mask_boundary=True,
|
| title=None):
|
| """
|
| 绘制速度场流线，思路参考 ``phi.vis.plot`` 中针对流线的处理流程（phi.torch.flow）。
|
| 通过 Runge-Kutta 积分追踪多条流线，支持根据速度着色、掩码约束和背景叠加。
|
|
|
| 参数:
|
| field: dict，至少包含 ``Ux``、``Uy``、``xGrid``、``yGrid``，可选 ``mask``、``p``。
|
| ax: Matplotlib Axes，若为 None 会创建新的图像。
|
| seed_density: 生成种子点的密度（基于网格尺寸，内部会自动限制总数量）。
|
| seeds: 手动指定种子点 (N,2)，单位与网格坐标一致。给定后忽略 seed_density。
|
| step_size: 空间步长，None 时自动取网格最小间距的一半。
|
| max_steps: 每个方向的积分步数上限。
|
| min_speed: 速度模低于该阈值即停止积分，避免停滞点振荡。
|
| color_mode: 'speed' 根据速度模着色；'constant' 使用 cmap 作为单一颜色。
|
| cmap: 着色方案；当 color_mode='constant' 时可为颜色字符串。
|
| linewidth: 流线宽度。
|
| background: 背景着色方式，'pressure' | 'velocity' | 'none' | ndarray。
|
| background_cmap/background_alpha: 背景 colormap 及透明度。
|
| add_colorbar: 是否为速度着色添加 colorbar。
|
| mask_boundary: 是否绘制固体边界轮廓。
|
| title: 可选标题。
|
| 返回:
|
| Matplotlib LineCollection 或 None。
|
| """
|
| if field is None:
|
| raise ValueError('field is required for plot_streamlines().')
|
| if color_mode not in ('speed', 'constant'):
|
| raise ValueError("color_mode must be either 'speed' or 'constant'.")
|
| if max_steps <= 0:
|
| raise ValueError('max_steps 必须为正整数。')
|
|
|
| fig = None
|
| if ax is None:
|
| fig, ax = plt.subplots(figsize=(6, 5))
|
| else:
|
| fig = ax.figure
|
|
|
| Ux_raw = _to_numpy(field.get('Ux')) if field.get('Ux') is not None else None
|
| Uy_raw = _to_numpy(field.get('Uy')) if field.get('Uy') is not None else None
|
| xGrid_raw = _to_numpy(field.get('xGrid')) if field.get('xGrid') is not None else None
|
| yGrid_raw = _to_numpy(field.get('yGrid')) if field.get('yGrid') is not None else None
|
| if Ux_raw is None or Uy_raw is None or xGrid_raw is None or yGrid_raw is None:
|
| raise ValueError("field must provide 'Ux', 'Uy', 'xGrid', 'yGrid'.")
|
|
|
| mask_raw = _to_numpy(field.get('mask')) if field.get('mask') is not None else np.zeros_like(Ux_raw, dtype=float)
|
|
|
| Ux = np.array(Ux_raw, dtype=float, copy=True)
|
| Uy = np.array(Uy_raw, dtype=float, copy=True)
|
| mask = np.array(mask_raw, dtype=float, copy=True)
|
| xGrid = np.array(xGrid_raw, dtype=float, copy=True)
|
| yGrid = np.array(yGrid_raw, dtype=float, copy=True)
|
|
|
| flip_x = xGrid.shape[1] > 1 and xGrid[0, 0] > xGrid[0, -1]
|
| flip_y = yGrid.shape[0] > 1 and yGrid[0, 0] > yGrid[-1, 0]
|
| if flip_x:
|
| Ux = np.flip(Ux, axis=1)
|
| Uy = np.flip(Uy, axis=1)
|
| mask = np.flip(mask, axis=1)
|
| xGrid = np.flip(xGrid, axis=1)
|
| yGrid = np.flip(yGrid, axis=1)
|
| if flip_y:
|
| Ux = np.flip(Ux, axis=0)
|
| Uy = np.flip(Uy, axis=0)
|
| mask = np.flip(mask, axis=0)
|
| xGrid = np.flip(xGrid, axis=0)
|
| yGrid = np.flip(yGrid, axis=0)
|
|
|
| xs = xGrid[0, :].astype(float)
|
| ys = yGrid[:, 0].astype(float)
|
| if xs.size < 2 or ys.size < 2:
|
| raise ValueError('流线绘制需要至少 2x2 的网格。')
|
|
|
| dx = float(np.median(np.diff(xs))) if xs.size > 1 else 1.0
|
| dy = float(np.median(np.diff(ys))) if ys.size > 1 else 1.0
|
| grid_step = min(abs(dx) if dx != 0 else np.inf, abs(dy) if dy != 0 else np.inf)
|
| if not np.isfinite(grid_step) or grid_step == 0:
|
| grid_step = 1.0
|
| if step_size is None:
|
| step_size = 0.5 * grid_step
|
|
|
| if not HAVE_SCIPY_INTERP:
|
| raise RuntimeError('scipy.interpolate.RegularGridInterpolator 未安装，无法使用高级流线整合。')
|
|
|
| fluid_mask = mask > 0.5
|
| if not np.any(fluid_mask):
|
| raise ValueError('未检测到流体区域，无法绘制流线。')
|
|
|
| Ux_interp = RegularGridInterpolator((ys, xs), Ux, bounds_error=False, fill_value=np.nan)
|
| Uy_interp = RegularGridInterpolator((ys, xs), Uy, bounds_error=False, fill_value=np.nan)
|
| mask_interp = RegularGridInterpolator((ys, xs), mask, method='nearest', bounds_error=False, fill_value=0.0)
|
|
|
| seed_density = float(seed_density)
|
| if seed_density <= 0:
|
| raise ValueError('seed_density 必须为正。')
|
|
|
| fluid_indices = np.argwhere(fluid_mask)
|
| y_idx_min, x_idx_min = fluid_indices.min(axis=0)
|
| y_idx_max, x_idx_max = fluid_indices.max(axis=0)
|
| domain_x = (xs[x_idx_min], xs[x_idx_max])
|
| domain_y = (ys[y_idx_min], ys[y_idx_max])
|
|
|
| if seeds is None:
|
| n_seed_x = max(3, int(len(xs) * seed_density))
|
| n_seed_y = max(3, int(len(ys) * seed_density))
|
| max_total_seeds = 600
|
| while n_seed_x * n_seed_y > max_total_seeds and (n_seed_x > 3 or n_seed_y > 3):
|
| if n_seed_x >= n_seed_y and n_seed_x > 3:
|
| n_seed_x -= 1
|
| elif n_seed_y > 3:
|
| n_seed_y -= 1
|
| else:
|
| break
|
| seed_x = np.linspace(domain_x[0], domain_x[1], n_seed_x)
|
| seed_y = np.linspace(domain_y[0], domain_y[1], n_seed_y)
|
| sx, sy = np.meshgrid(seed_x, seed_y)
|
| seeds = np.stack([sx.ravel(), sy.ravel()], axis=-1)
|
| else:
|
| seeds = np.asarray(seeds, dtype=float)
|
| if seeds.ndim != 2 or seeds.shape[1] != 2:
|
| raise ValueError('seeds 需要形状 (N, 2)。')
|
|
|
| def _interp(interpolator, pos):
|
| return interpolator(np.array([[pos[1], pos[0]]], dtype=float))[0]
|
|
|
| def inside(pos):
|
| return xs[0] <= pos[0] <= xs[-1] and ys[0] <= pos[1] <= ys[-1]
|
|
|
| def mask_value(pos):
|
| val = _interp(mask_interp, pos)
|
| return float(val) if np.isfinite(val) else 1.0
|
|
|
| valid_seed_list = []
|
| for seed in seeds:
|
| if not inside(seed):
|
| continue
|
| if mask_value(seed) <= 0.5:
|
| continue
|
| valid_seed_list.append(seed.astype(float))
|
| seeds = np.array(valid_seed_list, dtype=float)
|
| if seeds.size == 0:
|
| warnings.warn('未找到有效的流线起始点。', RuntimeWarning)
|
| return None
|
|
|
| visited = np.zeros_like(fluid_mask, dtype=bool)
|
|
|
| def grid_index(pos):
|
| ix = np.searchsorted(xs, pos[0], side='left') - 1
|
| iy = np.searchsorted(ys, pos[1], side='left') - 1
|
| ix = int(np.clip(ix, 0, len(xs) - 1))
|
| iy = int(np.clip(iy, 0, len(ys) - 1))
|
| return iy, ix
|
|
|
| def already_covered(pos):
|
| iy, ix = grid_index(pos)
|
| return visited[iy, ix]
|
|
|
| def mark_path(points):
|
| if points.size == 0:
|
| return
|
| ix = np.clip(np.searchsorted(xs, points[:, 0], side='left') - 1, 0, len(xs) - 1).astype(int)
|
| iy = np.clip(np.searchsorted(ys, points[:, 1], side='left') - 1, 0, len(ys) - 1).astype(int)
|
| visited[iy, ix] = True
|
|
|
| def velocity(pos):
|
| if not inside(pos):
|
| return None
|
| if mask_value(pos) <= 0.5:
|
| return None
|
| u = _interp(Ux_interp, pos)
|
| v = _interp(Uy_interp, pos)
|
| if not np.isfinite(u) or not np.isfinite(v):
|
| return None
|
| return np.array([float(u), float(v)], dtype=float)
|
|
|
| def rk4_step(pos, dt):
|
| k1 = velocity(pos)
|
| if k1 is None:
|
| return None, None
|
| k2 = velocity(pos + 0.5 * dt * k1)
|
| if k2 is None:
|
| return None, None
|
| k3 = velocity(pos + 0.5 * dt * k2)
|
| if k3 is None:
|
| return None, None
|
| k4 = velocity(pos + dt * k3)
|
| if k4 is None:
|
| return None, None
|
| vel_avg = (k1 + 2.0 * k2 + 2.0 * k3 + k4) / 6.0
|
| new_pos = pos + dt * vel_avg
|
| return new_pos, np.linalg.norm(vel_avg)
|
|
|
| def integrate_direction(seed_point, direction):
|
| pos = np.array(seed_point, dtype=float)
|
| path_points = [pos.copy()]
|
| segment_speeds = []
|
| for _ in range(int(max_steps)):
|
| vel = velocity(pos)
|
| if vel is None:
|
| break
|
| speed = np.linalg.norm(vel)
|
| if not np.isfinite(speed) or speed < min_speed:
|
| break
|
| dt = direction * (step_size / max(speed, min_speed))
|
| new_pos, avg_speed = rk4_step(pos, dt)
|
| if new_pos is None or not inside(new_pos):
|
| break
|
| if mask_value(new_pos) <= 0.5:
|
| break
|
| path_points.append(new_pos)
|
| segment_speeds.append(float(avg_speed if avg_speed is not None else speed))
|
| pos = new_pos
|
| return np.array(path_points, dtype=float), np.array(segment_speeds, dtype=float)
|
|
|
| def trace(seed_point):
|
| forward_pts, forward_speeds = integrate_direction(seed_point, 1.0)
|
| backward_pts, backward_speeds = integrate_direction(seed_point, -1.0)
|
| if forward_pts.shape[0] < 2 and backward_pts.shape[0] < 2:
|
| return None
|
| if backward_pts.shape[0] > 1:
|
| back_pts = backward_pts[::-1]
|
| back_speeds = backward_speeds[::-1]
|
| pts = np.vstack((back_pts[:-1], forward_pts))
|
| speeds = np.concatenate((back_speeds, forward_speeds))
|
| else:
|
| pts = forward_pts
|
| speeds = forward_speeds
|
| return pts, speeds
|
|
|
| segments = []
|
| segment_values = []
|
|
|
| rng = np.random.default_rng(42)
|
| rng.shuffle(seeds)
|
|
|
| for seed in seeds:
|
| if already_covered(seed):
|
| continue
|
| traced = trace(seed)
|
| if traced is None:
|
| continue
|
| pts, speeds = traced
|
| if pts.shape[0] < 2:
|
| continue
|
| segments.append(np.stack([pts[:-1], pts[1:]], axis=1))
|
| if color_mode == 'speed':
|
| if speeds.size == 0:
|
| speeds = np.zeros(pts.shape[0] - 1, dtype=float)
|
| segment_values.append(speeds)
|
| mark_path(pts)
|
|
|
| background_data = None
|
| if isinstance(background, str):
|
| key = background.lower()
|
| if key in ('pressure', 'p') and field.get('p') is not None:
|
| background_data = _to_numpy(field.get('p'))
|
| elif key in ('velocity', 'speed', 'magnitude'):
|
| background_data = np.sqrt(Ux ** 2 + Uy ** 2)
|
| elif background is not None:
|
| background_data = np.asarray(background, dtype=float)
|
|
|
| if background_data is not None:
|
| background_arr = np.array(background_data, dtype=float, copy=True)
|
| if background_arr.shape != Ux.shape:
|
| if background_arr.size == 1:
|
| background_arr = np.full(Ux.shape, float(background_arr.ravel()[0]), dtype=float)
|
| else:
|
| background_arr = None
|
| if background_arr is not None:
|
| if flip_x:
|
| background_arr = np.flip(background_arr, axis=1)
|
| if flip_y:
|
| background_arr = np.flip(background_arr, axis=0)
|
| background_masked = np.ma.array(background_arr, mask=mask <= 0.5)
|
| try:
|
| ax.pcolormesh(xGrid, yGrid, background_masked, shading='auto', cmap=background_cmap, alpha=background_alpha)
|
| except Exception:
|
| ax.imshow(background_masked.T, origin='lower', cmap=background_cmap, alpha=background_alpha)
|
|
|
| if mask_boundary:
|
| try:
|
| ax.contour(xGrid, yGrid, mask, levels=[0.5], colors='k', linewidths=0.5, alpha=0.6)
|
| except Exception:
|
| pass
|
|
|
| line_collection = None
|
| if segments:
|
| seg_array = np.concatenate(segments, axis=0)
|
| if color_mode == 'speed' and segment_values:
|
| values = np.concatenate(segment_values, axis=0)
|
| if not np.isfinite(values).any():
|
| values = np.zeros(seg_array.shape[0], dtype=float)
|
| vmin = float(np.nanmin(values))
|
| vmax = float(np.nanmax(values))
|
| if not np.isfinite(vmin):
|
| vmin = 0.0
|
| if not np.isfinite(vmax):
|
| vmax = 1.0
|
| if abs(vmax - vmin) < 1e-12:
|
| vmax = vmin + 1e-12
|
| norm = Normalize(vmin=vmin, vmax=vmax)
|
| line_collection = LineCollection(seg_array, linewidths=linewidth, cmap=cmap, norm=norm)
|
| line_collection.set_array(values)
|
| ax.add_collection(line_collection)
|
| if add_colorbar and fig is not None:
|
| fig.colorbar(line_collection, ax=ax, fraction=0.046, pad=0.04, label='|u|')
|
| else:
|
| color_value = cmap if isinstance(cmap, str) else 'k'
|
| line_collection = LineCollection(seg_array, linewidths=linewidth, colors=color_value)
|
| ax.add_collection(line_collection)
|
|
|
| ax.set_xlim(xs[0], xs[-1])
|
| ax.set_ylim(ys[0], ys[-1])
|
| if flip_y:
|
| ax.invert_yaxis()
|
| ax.set_aspect('equal', adjustable='box')
|
| ax.set_xlabel('x')
|
| ax.set_ylabel('y')
|
| if title:
|
| ax.set_title(title)
|
|
|
| if not segments:
|
| warnings.warn('未生成有效流线，已仅绘制背景。', RuntimeWarning)
|
| return line_collection
|
|
|
| @staticmethod
|
| def visualize(dataset, indices=None, mask_mode='nan', save_dir=None,
|
| to_video=False, video_name='out.mp4', fps=10,
|
| cmap='viridis', pressure_cmap='plasma', show=False,
|
| clip_percentile=99, add_contours=False, contour_levels=10,
|
| add_streamlines=False, stream_density=1.0, ffmpeg_path='./',
|
| stream_kwargs=None):
|
| """
|
| 静态可视化方法：接受一个 dataset 实例（或任何具有 __getitem__ 的对象）和若干时间步索引，
|
| 将每一帧绘制为基于坐标的伪彩图（使用 pcolormesh），并可选择保存每帧到磁盘并用 ffmpeg 合成视频。
|
|
|
| 参数：
|
| - dataset: OpenfoamDataset 实例或兼容接口
|
| - indices: None 或索引列表（None 表示全部时间步）
|
| - mask_mode: 固体区域掩码处理方式，支持 'nan'（默认）或 'zero'
|
| - save_dir: 若指定则保存逐帧 PNG 到该目录
|
| - to_video: 若 True 则在保存完帧后调用 ffmpeg 合成视频 (需要系统安装 ffmpeg)
|
| - video_name: 生成的视频文件名（位于 save_dir）
|
| - fps: 视频帧率
|
| - cmap / pressure_cmap: 颜色映射
|
| - show: 是否在每帧显示窗口（会阻塞，适用于交互）
|
| - ffmpeg_path: ffmpeg/bin 的路径（用于添加环境变量，确保ffmpeg命令可运行）
|
| - stream_kwargs: dict，可选流线绘制参数，透传给 plot_streamlines()
|
| """
|
|
|
| if indices is None:
|
| try:
|
| n = len(dataset)
|
| indices = list(range(n))
|
| except Exception:
|
| indices = [0]
|
|
|
| if save_dir:
|
| os.makedirs(save_dir, exist_ok=True)
|
|
|
| def to_numpy(x):
|
| try:
|
| return x.cpu().numpy()
|
| except Exception:
|
| return np.array(x)
|
|
|
| def _fallback_streamplot(ax, x_grid, y_grid, pressure_field, Ux_field, Uy_field,
|
| density_value, contour_flag, contour_levels_value):
|
| try:
|
| ax.pcolormesh(x_grid, y_grid, pressure_field, shading='auto', cmap=pressure_cmap, alpha=0.25)
|
| except Exception:
|
| pass
|
| xs_local = np.unique(x_grid[0, :]) if x_grid.ndim == 2 else np.linspace(np.min(x_grid), np.max(x_grid), Ux_field.shape[1])
|
| ys_local = np.unique(y_grid[:, 0]) if y_grid.ndim == 2 else np.linspace(np.min(y_grid), np.max(y_grid), Ux_field.shape[0])
|
| if ys_local[0] > ys_local[-1]:
|
| ys_for_plot = ys_local[::-1]
|
| U_plot = np.flipud(Ux_field)
|
| V_plot = np.flipud(Uy_field)
|
| else:
|
| ys_for_plot = ys_local
|
| U_plot = Ux_field
|
| V_plot = Uy_field
|
| try:
|
| ax.streamplot(xs_local, ys_for_plot, U_plot, V_plot, density=density_value, color='k', linewidth=0.6, arrowsize=1.0)
|
| except Exception:
|
| pass
|
| if contour_flag:
|
| try:
|
| ax.contour(x_grid, y_grid, pressure_field, levels=contour_levels_value, colors='k', linewidths=0.5)
|
| except Exception:
|
| pass
|
|
|
| base_stream_kwargs = dict(stream_kwargs) if stream_kwargs is not None else {}
|
|
|
| frame_paths = []
|
| frame_counter = 0
|
| for idx in indices:
|
| sample = dataset[idx]
|
| if not isinstance(sample, (list, tuple)) or len(sample) != 2:
|
| raise TypeError('Dataset __getitem__ must return (fields_seq, infos_seq).')
|
| fields_seq, infos_seq = sample
|
| if len(fields_seq) != len(infos_seq):
|
| raise ValueError('fields_seq and infos_seq must have the same length.')
|
|
|
| for step_offset, (field, info) in enumerate(zip(fields_seq, infos_seq)):
|
| Ux = to_numpy(field.get('Ux'))
|
| Uy = to_numpy(field.get('Uy'))
|
| p = to_numpy(field.get('p'))
|
| xGrid = to_numpy(field.get('xGrid'))
|
| yGrid = to_numpy(field.get('yGrid'))
|
| mask = to_numpy(field.get('mask'))
|
|
|
| def apply_mask(arr):
|
| a = arr.copy()
|
| try:
|
| mask_arr = np.asarray(mask)
|
| if mask_arr.dtype == bool:
|
| solid_region = ~mask_arr
|
| else:
|
| solid_region = mask_arr < 0.5
|
| if mask_mode == 'zero':
|
| a[solid_region] = 0.0
|
| elif mask_mode == 'keep':
|
| pass
|
| else:
|
| a = np.where(solid_region, np.nan, a)
|
| except Exception:
|
| pass
|
| return a
|
|
|
| p_vis = apply_mask(p)
|
| vel = np.sqrt(np.nan_to_num(Ux)**2 + np.nan_to_num(Uy)**2)
|
| vel_vis = apply_mask(vel)
|
|
|
| try:
|
| x_1d = xGrid[0, :]
|
| y_1d = yGrid[:, 0]
|
| dudx = np.gradient(Ux, x_1d, axis=1)
|
| dudy = np.gradient(Ux, y_1d, axis=0)
|
| dvdx = np.gradient(Uy, x_1d, axis=1)
|
| dvdy = np.gradient(Uy, y_1d, axis=0)
|
| vorticity = dvdx - dudy
|
| except Exception:
|
| vorticity = np.zeros_like(Ux)
|
| vort_vis = apply_mask(vorticity)
|
|
|
| fig = plt.figure(figsize=(12, 10))
|
| gs = fig.add_gridspec(2, 2, left=0.07, right=0.95, top=0.96, bottom=0.05, wspace=0.12, hspace=0.18)
|
| ax_vort = fig.add_subplot(gs[0, 0])
|
| ax_press = fig.add_subplot(gs[0, 1])
|
| ax_stream = fig.add_subplot(gs[1, 0])
|
| ax_vel = fig.add_subplot(gs[1, 1])
|
|
|
| try:
|
| if clip_percentile is not None and clip_percentile > 0:
|
| valid = p_vis[~np.isnan(p_vis)] if np.any(~np.isnan(p_vis)) else np.array([])
|
| if valid.size > 0:
|
| vmin = np.percentile(valid, 100 - clip_percentile)
|
| vmax = np.percentile(valid, clip_percentile)
|
| else:
|
| vmin, vmax = None, None
|
| else:
|
| vmin, vmax = None, None
|
| pcm_press = ax_press.pcolormesh(xGrid, yGrid, p_vis, shading='auto', cmap=pressure_cmap, vmin=vmin, vmax=vmax)
|
| except Exception:
|
| pcm_press = ax_press.imshow(p_vis.T if p_vis.ndim == 2 else p_vis, origin='lower', cmap=pressure_cmap)
|
| ax_press.set_title(f'Pressure (sample={idx}, step={step_offset}, time={info.get("time")})')
|
| fig.colorbar(pcm_press, ax=ax_press, fraction=0.046, pad=0.04)
|
| try:
|
| ax_press.set_aspect('equal', adjustable='box')
|
| except Exception:
|
| pass
|
|
|
| try:
|
| pcm_vort = ax_vort.pcolormesh(xGrid, yGrid, vort_vis, shading='auto', cmap='bwr')
|
| except Exception:
|
| pcm_vort = ax_vort.imshow(vort_vis.T if vort_vis.ndim == 2 else vort_vis, origin='lower', cmap='bwr')
|
| ax_vort.set_title(f'Vorticity (sample={idx}, step={step_offset})')
|
| fig.colorbar(pcm_vort, ax=ax_vort, fraction=0.046, pad=0.04)
|
| try:
|
| ax_vort.set_aspect('equal', adjustable='box')
|
| except Exception:
|
| pass
|
|
|
| stream_field = {
|
| 'Ux': field.get('Ux'),
|
| 'Uy': field.get('Uy'),
|
| 'xGrid': field.get('xGrid'),
|
| 'yGrid': field.get('yGrid'),
|
| 'mask': field.get('mask'),
|
| 'p': field.get('p')
|
| }
|
| if add_streamlines:
|
| local_stream_kwargs = dict(base_stream_kwargs)
|
| local_stream_kwargs.setdefault('seed_density', stream_density)
|
| local_stream_kwargs.setdefault('background', 'pressure')
|
| local_stream_kwargs.setdefault('cmap', cmap)
|
| local_stream_kwargs.setdefault('add_colorbar', False)
|
| local_stream_kwargs.setdefault('mask_boundary', True)
|
| local_stream_kwargs.setdefault('title', f'Streamlines (sample={idx}, step={step_offset})')
|
| try:
|
| OpenfoamDataset.plot_streamlines(stream_field, ax=ax_stream, **local_stream_kwargs)
|
| except Exception as exc:
|
| warnings.warn(f'plot_streamlines failed ({exc!r}); falling back to matplotlib.streamplot()', RuntimeWarning)
|
| _fallback_streamplot(ax_stream, xGrid, yGrid, p_vis, Ux, Uy, stream_density, add_contours, contour_levels)
|
| ax_stream.set_title(f'Streamlines (sample={idx}, step={step_offset})')
|
| else:
|
| _fallback_streamplot(ax_stream, xGrid, yGrid, p_vis, Ux, Uy, stream_density, add_contours, contour_levels)
|
| ax_stream.set_title(f'Streamlines (sample={idx}, step={step_offset})')
|
| try:
|
| ax_stream.set_aspect('equal', adjustable='box')
|
| except Exception:
|
| pass
|
|
|
| try:
|
| pcm_vel = ax_vel.pcolormesh(xGrid, yGrid, vel_vis, shading='auto', cmap=cmap)
|
| except Exception:
|
| pcm_vel = ax_vel.imshow(vel_vis.T if vel_vis.ndim == 2 else vel_vis, origin='lower', cmap=cmap)
|
| ax_vel.set_title(f'Velocity magnitude (sample={idx}, step={step_offset})')
|
| fig.colorbar(pcm_vel, ax=ax_vel, fraction=0.046, pad=0.04)
|
| try:
|
| ax_vel.set_aspect('equal', adjustable='box')
|
| except Exception:
|
| pass
|
|
|
| if save_dir:
|
| out_path = os.path.join(save_dir, f'frame_{frame_counter:06d}.png')
|
| fig.savefig(out_path, dpi=150)
|
| frame_paths.append(out_path)
|
| print(f'[visualize] saved {out_path}')
|
| if show:
|
| plt.show()
|
| else:
|
| plt.close(fig)
|
|
|
| frame_counter += 1
|
|
|
|
|
| if to_video:
|
| os.environ["PATH"] = ffmpeg_path + os.pathsep + os.environ["PATH"]
|
| if not save_dir:
|
| raise ValueError('to_video=True 时必须提供 save_dir 用于存放帧')
|
| out_video = os.path.join(save_dir, video_name)
|
| input_pattern = os.path.join(save_dir, 'frame_%06d.png')
|
| scale_filter = 'scale=iw/2:ih/2'
|
| cmd = ['ffmpeg', '-y', '-framerate', str(fps), '-i', input_pattern, '-vf', scale_filter, '-c:v', 'libx264', '-pix_fmt', 'yuv420p', out_video]
|
| try:
|
| print('[visualize] running ffmpeg to create video...')
|
| subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
| print(f'[visualize] video saved to {out_video}')
|
| except FileNotFoundError:
|
| raise RuntimeError('ffmpeg 未找到：请在系统路径中安装 ffmpeg，或将其可执行文件路径添加到 PATH')
|
| except subprocess.CalledProcessError as e:
|
| raise RuntimeError(f'ffmpeg failed: {e.stderr.decode(errors="ignore")}')
|
|
|
|
|
| class OpenfoamDataset_Only4AE(OpenfoamDataset):
|
| def __getitem__(self, index):
|
| fields_seq, _ = super().__getitem__(index)
|
| return fields_seq
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| class ConcatDatasetsWrapper(Dataset):
|
| """Wrap multiple dataset instances (possibly heterogeneous) into a single dataset.
|
|
|
| datasets_descriptors: sequence where each element can be either:
|
| - a path (str/Path) -> will be constructed using dataset_cls (default OpenfoamDataset)
|
| - a tuple (path, dataset_cls) -> constructed with dataset_cls(path, number_of_steps_to_get, ...)
|
| - a tuple (path, dataset_cls, kwargs_dict) -> constructed with dataset_cls(path, number_of_steps_to_get, **kwargs_dict)
|
|
|
| This allows assembling heterogeneous dataset classes into one virtual dataset.
|
| """
|
| def __init__(self, datasets_descriptors, number_of_steps_to_get, *args, **kwargs):
|
| self.datasets_descriptors = list(datasets_descriptors)
|
| self._number_of_steps_to_get = number_of_steps_to_get
|
|
|
| self._default_dataset_cls = OpenfoamDataset
|
| self._default_args = args
|
| self._default_kwargs = dict(kwargs)
|
|
|
| self.datasets_list = []
|
| for desc in self.datasets_descriptors:
|
| if isinstance(desc, (str, os.PathLike)):
|
| path = os.fspath(desc)
|
| cls = self._default_dataset_cls
|
| k = dict(self._default_kwargs)
|
| elif isinstance(desc, Sequence) and len(desc) >= 2:
|
| path = os.fspath(desc[0])
|
| cls = desc[1] or self._default_dataset_cls
|
| k = dict(self._default_kwargs)
|
| if len(desc) >= 3 and isinstance(desc[2], dict):
|
| k.update(desc[2])
|
| else:
|
| raise TypeError('Each datasets_descriptors element must be path or (path, cls[, kwargs])')
|
|
|
| ds = cls(path, self._number_of_steps_to_get, *self._default_args, **k)
|
| self.datasets_list.append(ds)
|
|
|
|
|
| if self.datasets_list:
|
|
|
| self.collate_fn = getattr(self.datasets_list[0], 'collate_fn', OpenfoamDataset.collate_fn)
|
|
|
| def __len__(self):
|
| return sum(len(i) for i in self.datasets_list)
|
|
|
| def __getitem__(self, idx):
|
| idx_sample_internal = idx
|
| for i, ds in enumerate(self.datasets_list):
|
| if idx_sample_internal < len(ds):
|
| return ds[idx_sample_internal]
|
| idx_sample_internal -= len(ds)
|
| raise IndexError('index out of range')
|
|
|
|
|
| def create_dataloader_of(data_path,
|
| number_of_steps_to_get=2,
|
| batch_size=1,
|
| shuffle=True,
|
| num_workers=0,
|
| pin_memory=True,
|
| drop_last=False,
|
| collate_fn=None,
|
| distributed=False,
|
| world_size=1,
|
| rank=0,
|
| seed=None,
|
| persistent_workers=False,
|
| prefetch_factor=2,
|
| generator=None,
|
| device=None,
|
| dtype=None,
|
| **dataset_kwargs):
|
| """Create a DataLoader for a single OpenfoamDataset.
|
|
|
| Args:
|
| data_path: Path to OpenFOAM case directory (single dataset).
|
| number_of_steps_to_get: Number of time steps to load per sample.
|
| batch_size: Batch size for DataLoader.
|
| shuffle: Whether to shuffle the dataset.
|
| num_workers: Number of worker processes for data loading.
|
| pin_memory: Pin memory for faster GPU transfer.
|
| drop_last: Drop last incomplete batch.
|
| collate_fn: Custom collate function (defaults to OpenfoamDataset.collate_fn).
|
| distributed: Enable distributed sampler.
|
| world_size: Number of distributed processes.
|
| rank: Rank of current process.
|
| seed: Random seed for reproducibility.
|
| persistent_workers: Keep workers alive between epochs.
|
| prefetch_factor: Number of batches to prefetch per worker.
|
| generator: Random generator for sampling.
|
| device: torch 设备（覆盖 Dataset 初始化时的 device 参数）。
|
| dtype: torch dtype（覆盖 Dataset 初始化时的 dtype 参数）。
|
| **dataset_kwargs: Additional arguments passed to OpenfoamDataset constructor.
|
|
|
| Returns:
|
| torch.utils.data.DataLoader instance.
|
| """
|
| if not HAVE_TORCH:
|
| raise RuntimeError('torch is required to create a DataLoader.')
|
|
|
| dataset_kwargs = dict(dataset_kwargs)
|
| if device is not None:
|
| dataset_kwargs.setdefault('device', device)
|
| if dtype is not None:
|
| dataset_kwargs.setdefault('dtype', dtype)
|
|
|
|
|
| dataset = OpenfoamDataset(
|
| root_dir=data_path,
|
| number_of_steps_to_get=number_of_steps_to_get,
|
| **dataset_kwargs
|
| )
|
|
|
|
|
| if collate_fn is None:
|
| collate_fn = OpenfoamDataset.collate_fn
|
|
|
|
|
| sampler = None
|
| final_world_size = max(1, int(world_size))
|
| if distributed or final_world_size > 1:
|
| sampler = torch.utils.data.distributed.DistributedSampler(
|
| dataset,
|
| num_replicas=final_world_size,
|
| rank=int(rank),
|
| shuffle=bool(shuffle)
|
| )
|
| shuffle = False
|
|
|
|
|
| worker_init_fn = None
|
| if seed is not None:
|
| base_seed = int(seed)
|
|
|
| def _init_fn(worker_id):
|
| worker_seed = base_seed + worker_id
|
| np.random.seed(worker_seed)
|
| random.seed(worker_seed)
|
| torch.manual_seed(worker_seed)
|
|
|
| worker_init_fn = _init_fn
|
|
|
| if generator is None:
|
| generator = torch.Generator()
|
| generator.manual_seed(base_seed)
|
|
|
| batch_size = min(batch_size, len(dataset))
|
| nd = torch.cuda.device_count()
|
| num_workers = min([os.cpu_count() // max(nd, 1), batch_size if batch_size > 1 else 0, num_workers])
|
|
|
|
|
| loader_kwargs = dict(
|
| dataset=dataset,
|
| batch_size=batch_size,
|
| shuffle=bool(shuffle) if sampler is None else False,
|
| sampler=sampler,
|
| num_workers=num_workers,
|
| pin_memory=pin_memory,
|
| drop_last=drop_last,
|
| collate_fn=collate_fn,
|
| worker_init_fn=worker_init_fn,
|
| generator=generator
|
| )
|
|
|
| if num_workers > 0:
|
| loader_kwargs['persistent_workers'] = bool(persistent_workers)
|
| if prefetch_factor is not None:
|
| loader_kwargs['prefetch_factor'] = prefetch_factor
|
|
|
| return DataLoader(**loader_kwargs)
|
|
|
|
|
| def create_dataloader_cat(datasets_descriptors,
|
| number_of_steps_to_get=2,
|
| batch_size=1,
|
| shuffle=True,
|
| num_workers=0,
|
| pin_memory=True,
|
| drop_last=False,
|
| collate_fn=None,
|
| distributed=False,
|
| world_size=1,
|
| rank=0,
|
| seed=None,
|
| persistent_workers=False,
|
| prefetch_factor=2,
|
| generator=None,
|
| device=None,
|
| dtype=None,
|
| **dataset_kwargs):
|
| """Create a DataLoader backed by ConcatDatasetsWrapper for multiple datasets.
|
|
|
| Args:
|
| datasets_descriptors: Sequence of dataset descriptors, each can be:
|
| - a path (str/PathLike) -> constructed with OpenfoamDataset
|
| - a tuple (path, dataset_cls) -> constructed with custom class
|
| - a tuple (path, dataset_cls, kwargs_dict) -> with extra kwargs
|
| number_of_steps_to_get: Number of time steps to load per sample.
|
| batch_size: Batch size for DataLoader.
|
| shuffle: Whether to shuffle the dataset.
|
| num_workers: Number of worker processes for data loading.
|
| pin_memory: Pin memory for faster GPU transfer.
|
| drop_last: Drop last incomplete batch.
|
| collate_fn: Custom collate function (defaults to first dataset's collate_fn).
|
| distributed: Enable distributed sampler.
|
| world_size: Number of distributed processes.
|
| rank: Rank of current process.
|
| seed: Random seed for reproducibility.
|
| persistent_workers: Keep workers alive between epochs.
|
| prefetch_factor: Number of batches to prefetch per worker.
|
| generator: Random generator for sampling.
|
| device: torch 设备（覆盖内部 Dataset 初始化的 device 参数）。
|
| dtype: torch dtype（覆盖内部 Dataset 初始化的 dtype 参数）。
|
| **dataset_kwargs: Additional arguments passed to dataset constructors.
|
|
|
| Returns:
|
| torch.utils.data.DataLoader instance.
|
| """
|
| if not HAVE_TORCH:
|
| raise RuntimeError('torch is required to create a DataLoader.')
|
|
|
|
|
| dataset_kwargs = dict(dataset_kwargs)
|
| if device is not None:
|
| dataset_kwargs.setdefault('device', device)
|
| if dtype is not None:
|
| dataset_kwargs.setdefault('dtype', dtype)
|
|
|
| dataset = ConcatDatasetsWrapper(
|
| datasets_descriptors=datasets_descriptors,
|
| number_of_steps_to_get=number_of_steps_to_get,
|
| **dataset_kwargs
|
| )
|
|
|
|
|
| if collate_fn is None:
|
| collate_fn = getattr(dataset, 'collate_fn', OpenfoamDataset.collate_fn)
|
|
|
|
|
| sampler = None
|
| final_world_size = max(1, int(world_size))
|
| if distributed or final_world_size > 1:
|
| sampler = torch.utils.data.distributed.DistributedSampler(
|
| dataset,
|
| num_replicas=final_world_size,
|
| rank=int(rank),
|
| shuffle=bool(shuffle)
|
| )
|
| shuffle = False
|
|
|
|
|
| worker_init_fn = None
|
| if seed is not None:
|
| base_seed = int(seed)
|
|
|
| def _init_fn(worker_id):
|
| worker_seed = base_seed + worker_id
|
| np.random.seed(worker_seed)
|
| random.seed(worker_seed)
|
| torch.manual_seed(worker_seed)
|
|
|
| worker_init_fn = _init_fn
|
|
|
| if generator is None:
|
| generator = torch.Generator()
|
| generator.manual_seed(base_seed)
|
|
|
| batch_size = min(batch_size, len(dataset))
|
| nd = torch.cuda.device_count()
|
| num_workers = min([os.cpu_count() // max(nd, 1), batch_size if batch_size > 1 else 0, num_workers])
|
|
|
|
|
| loader_kwargs = dict(
|
| dataset=dataset,
|
| batch_size=batch_size,
|
| shuffle=bool(shuffle) if sampler is None else False,
|
| sampler=sampler,
|
| num_workers=num_workers,
|
| pin_memory=pin_memory,
|
| drop_last=drop_last,
|
| collate_fn=collate_fn,
|
| worker_init_fn=worker_init_fn,
|
| generator=generator
|
| )
|
|
|
| if num_workers > 0:
|
| loader_kwargs['persistent_workers'] = bool(persistent_workers)
|
| if prefetch_factor is not None:
|
| loader_kwargs['prefetch_factor'] = prefetch_factor
|
|
|
| return DataLoader(**loader_kwargs)
|
|
|
|
|
| if __name__ == "__main__":
|
| import argparse
|
|
|
| parser = argparse.ArgumentParser(description='OpenFOAM dataloader quick sanity checks')
|
| parser.add_argument('--data', type=str, default='./env19', help='OpenFOAM case 路径')
|
| parser.add_argument('--step', type=int, default=0, help='预览的时间步索引')
|
|
|
| parser.add_argument('--save-dir', type=str, default='./test_loader', help='可视化输出目录 (若启用)')
|
| args = parser.parse_args()
|
|
|
|
|
| print('\n[Example 1] OpenfoamDataset 使用示例')
|
| dataset = OpenfoamDataset(args.data, number_of_steps_to_get=2, device="cuda")
|
| print(' 总样本数:', len(dataset))
|
| fields_seq, infos_seq = dataset[args.step]
|
| print(' 样本时间序列长度:', len(fields_seq))
|
| if fields_seq:
|
| print(' 第 0 帧字段键:', list(fields_seq[0].keys()))
|
| for key, value in fields_seq[0].items():
|
| if HAVE_TORCH and torch.is_tensor(value):
|
| print(f' {key}: tensor shape={tuple(value.shape)} dtype={value.dtype}')
|
| else:
|
| print(f' {key}: type={type(value)}')
|
| if infos_seq:
|
| print(' 第 0 帧 info 键:', list(infos_seq[0].keys()))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| print('\n[Example 2] create_dataloader_of 使用示例')
|
| dataloader = create_dataloader_of(args.data, batch_size=2, shuffle=False, num_workers=0, device='cpu')
|
| batch_fields, batch_infos = next(iter(dataloader))
|
| print(' 批次时间序列长度:', len(batch_fields))
|
| if batch_fields:
|
| print(' 第 0 步字段键:', list(batch_fields[0].keys()))
|
| for key, value in batch_fields[0].items():
|
| if HAVE_TORCH and torch.is_tensor(value):
|
| print(f' {key}: tensor shape={tuple(value.shape)} dtype={value.dtype}')
|
| if batch_infos:
|
| print(' 第 0 步 info 键:', list(batch_infos[0].keys()))
|
|
|
|
|
| print('\n[Example 3] ConcatDatasetsWrapper 使用示例')
|
| concat_dataset = ConcatDatasetsWrapper([args.data, args.data], number_of_steps_to_get=2)
|
| print(' 总样本数:', len(concat_dataset))
|
| concat_fields, concat_infos = concat_dataset[args.step]
|
| print(' 样本时间序列长度:', len(concat_fields))
|
| if concat_fields:
|
| print(' 第 0 帧字段键:', list(concat_fields[0].keys()))
|
| for key, value in concat_fields[0].items():
|
| if HAVE_TORCH and torch.is_tensor(value):
|
| print(f' {key}: tensor shape={tuple(value.shape)} dtype={value.dtype}')
|
| if concat_infos:
|
| print(' 第 0 帧 info 键:', list(concat_infos[0].keys()))
|
|
|
| os.makedirs(args.save_dir, exist_ok=True)
|
| OpenfoamDataset.visualize(concat_dataset, indices=None, save_dir=args.save_dir, show=False)
|
| print(f' 可视化结果保存在 {args.save_dir}')
|
|
|
| frame_pattern = os.path.join(args.save_dir, 'frame_%06d.png')
|
| video_path = os.path.join(args.save_dir, 'preview.mp4')
|
| if shutil.which('ffmpeg'):
|
| cmd = ['ffmpeg', '-y', '-framerate', '5', '-i', frame_pattern, '-c:v', 'libx264', '-pix_fmt', 'yuv420p', video_path]
|
| try:
|
| subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
| print(f' 已合成视频: {video_path}')
|
| except subprocess.CalledProcessError as exc:
|
| err_msg = exc.stderr.decode(errors='ignore') if exc.stderr else str(exc)
|
| print(f' ⚠️ ffmpeg 合成失败: {err_msg[:200]}')
|
| else:
|
| print(' ⚠️ 未检测到 ffmpeg，跳过视频合成')
|
|
|
|
|
| print('\n[Example 4] create_dataloader_cat 使用示例')
|
| concat_loader = create_dataloader_cat([args.data, args.data], batch_size=2, shuffle=False, num_workers=0)
|
| cat_fields, cat_infos = next(iter(concat_loader))
|
| print(' 批次时间序列长度:', len(cat_fields))
|
| if cat_fields:
|
| print(' 第 0 步字段键:', list(cat_fields[0].keys()))
|
| for key, value in cat_fields[0].items():
|
| if HAVE_TORCH and torch.is_tensor(value):
|
| print(f' {key}: tensor shape={tuple(value.shape)} dtype={value.dtype}')
|
| if cat_infos:
|
| print(' 第 0 步 info 键:', list(cat_infos[0].keys()))
|
|
|
|
|
| print('\n✅ 示例执行完毕')
|
|
|
|
|
|
|
