scripts/data_trans/openfoam_dataload.py

"""

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
    # minimal stand-ins so class definition still works when torch absent
    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',   # ✅ NOTE 建议使用cpu模式(在训练循环中手动to(device)), 因为 dataloader 启用 pin-memory 时要求 CPU tensor

                 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
        # vector_keep_dims: which components to keep from vector fields (e.g. [0,1] -> x,y)
        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
        # dtype 决定在 runtime，如果 torch 可用则默认 torch.float32
        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()
        # 以第一个时间步的C文件为网格中心
        self.grid_points, self.Nx, self.Ny, self.xs, self.ys = self._load_structured_grid()
        # 更新类属性（实例级信息）: n_fluid_points = Nx * Ny, n_time_steps = len(time_dirs)
        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)

        # check len
        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):
        # 查找所有时间步文件夹（数字命名），若当前目录本身就是时间步（如0/1/2），则返回['.']
        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):
        # 用C文件（网格中心）定义结构化网格
        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')
        # 读取 C 文件为 point list (n, n_dim)
        # 先尝试读取 header 中声明的数量并保存到类属性
        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))
        # 保证只取 x,y 或者用户指定的分量
        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]
        # 只保留前两列作为 x,y（如果用户只保留了一维也兼容）
        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))
        # 我们的张量约定：i 方向对应 -y（从上到下），j 方向对应 x（从左到右）
        # 因此让 i 对应于 ys 的降序索引
        ys_desc = ys[::-1]
        Nx = len(ys_desc)   # number of i (rows)
        Ny = len(xs)        # number of j (cols)
        # 生成结构化网格点 (Nx, Ny, 2)
        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
        # 返回时仍然给出原始 xs, ys（xs 升序，ys 升序）以便上层使用
        return grid_points, Nx, Ny, xs, ys

    def _parse_internal_list_count(self, path):
        # 从文件中解析 nonuniform List<...> 后面的数量（用于 uniform 时推断点数）
        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()

        # nonuniform List 区块优先：header 可能是两行（类型/数量换行），随后是括号包裹的列表
        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))
            # 更稳健地提取括号块：匹配单独一行的 '(' 和相应的 ')'（DOTALL + MULTILINE）
            # 首先尝试匹配 ( ... ) ; 这种情况，确保 ) 后面紧跟 ; 或随后的换行再是 ;
            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}")
                # 找到第一个单独的行起始的 ')' 后面跟着可选空白与 ';'
                # 为保险，查找 pattern '\n)\s*;'
                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:
                # 这里仍旧发出警告，但我们将使用 header 中的 n_decl 作为 n_fluid_points
                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]
                # 当这是 C 文件（vector 且对象名为 C）时，我们希望记录 header 中的点数作为 n_fluid_points
                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)

        # uniform 情形：匹配 internalField uniform ... ;（值可以是 0 或者 (a b c)）
        m_uni = re.search(r'internalField\s+uniform\s*(.*?);', content, re.DOTALL)
        if m_uni:
            token = m_uni.group(1).strip()
            # token 可能是 '0' 或者 '(0)' 或 '(0 0 0)'
            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
            # 尝试从 C 文件推断点数
            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):
        # 从 system/transportProperties 文件中提取物性参数或其他标识（例如 rho, mu, nu, Re）
        # 默认 rho = 1.0（若文件中未找到则使用默认）
        rho, mu, nu = 1.0, None, None
        Re_val = None
        # search both constant/ and system/ directories (transportProperties often lives in constant/)
        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)
                # also scan other files in this dir for Re-like comments/values
                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
            # 查找 Re 或 Re_blockage（注释里也可能出现）
            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
            # 查找 nu，兼容 transportProperties 中的形式：nu [units] 5e-3; 或 nu 5e-3;
            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
            # mu, rho：transportProperties 中可能以 mu 或 rho 名义出现
            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
        # 如果未找到，则尝试计算，实在无数据，则使用默认 1.0 填充
        if rho is None:
            rho = 1.0
        if mu is None:
            # 尝试用 rho*nu 计算
            try:
                mu = float(rho) * float(nu)
            except Exception:
                mu = 1.0
        if nu is None:
            # 尝试用 mu/rho 计算
            try:
                nu = float(mu) / float(rho) if rho != 0 else 1.0
            except Exception:
                nu = 1.0

        info = {'rho': rho, 'mu': mu, 'nu': nu}
        # 统一使用 'Re' 键；如果在文件中找到 Re 或 Re_blockage，则写入
        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
        # 更稳健地提取 boundaryField 块（处理嵌套花括号）
        def _extract_brace_block(s, start_idx):
            # 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

        # 在 boundaryField 块中寻找以 'inlet' 为 patch 名或包含 'inlet' 的块，提取其 value 字段
        # 更简单的做法：在 bf_block 中按块级别查找包含 'inlet' 关键字的子块并使用其 value
        inlet_block = None
        for m in re.finditer(r'([A-Za-z0-9_\-]+)\s*\{', bf_block):
            name = m.group(1)
            # 如果名字包含 inlet（更宽松匹配），提取该块
            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:
            # 无明确 patch 名含 inlet，则在 boundaryField 中寻找第一个包含 value 且类型为 fixedValue 的 patch
            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

        # 在 inlet_block 中寻找 value 字段
        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))
            # 返回时只保留 value（不要返回 patch 名称，避免把 outlet 等误识别带入上层）
            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)
            # return bbox in (xmin, ymin, xmax, ymax) order
            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

        """
        # 优先在 root_dir/system/controlDict 查找，再在 case_dir/system/controlDict
        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
        # fallback: try numeric time_dir name
        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):
        # 读取 C, U, p 文件，使用统一的解析器
        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)

        # 读取点坐标列表 (n, ndim)
        point_list = np.array(self._read_field(c_path, vector=True))
        if point_list.ndim == 1:
            point_list = point_list.reshape(-1, 1)
        # 只保留用户感兴趣的分量作为 x,y
        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]

        # 读取速度（vector）和压力（scalar）
        U = np.array(self._read_field(U_path, vector=True))
        p = np.array(self._read_field(p_path, vector=False))

        # 校验：U, p 与 C 的点数一致
        n_pts = point_list.shape[0]
        # 如果 C 文件声明了 internalField 的点数（nonuniform List<...> 后的整数），使用该声明进行严格校验
        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:
            # 若找不到 C 文件则在后续的点匹配处会触发其它错误，继续让原有错误抛出
            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, ys)
        xs = np.unique(np.round(point_list[:, 0], self.coord_digits))
        ys = np.unique(np.round(point_list[:, 1], self.coord_digits))
        # i 对应 -y（从上到下），因此使用 ys 的降序作为 i 方向
        ys_desc = ys[::-1]
        Nx = len(ys_desc)   # i dimension (rows)
        Ny = len(xs)        # j dimension (cols)
        # 生成 xGrid/yGrid，使得 xGrid[i,j]=xs[j], yGrid[i,j]=ys_desc[i]
        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

        # 建立从坐标到结构化索引的映射（以 round 精确匹配）：注意 i 使用 ys_desc
        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)  # True=fluid, False=solid（初始化为全固体）

        # 建立映射字典：point index -> (ix,iy)
        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 列表 (未使用但保留)
        solid_points = [tuple(idx) for idx in np.argwhere(~solid_mask)]

        # 对固体区域填充：速度 0，压力用最近流体点插值
        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

        # 生成输出：统一把 numpy 数组转换为 contiguous numpy 后用 torch.from_numpy 转为 torch.Tensor
        def _to_tensor(arr):
            # 将数组转换为 contiguous numpy 并在 Dataset 层转为 torch.Tensor
            a = np.ascontiguousarray(np.asarray(arr))
            if HAVE_TORCH:
                # 按要求使用 torch.from_numpy(np.ascontiguousarray(np.asarray(v))).float()
                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)
        # mask: 保证语义为 1=fluid, 0=solid（solid_mask: True 表示流体）
        fluid_mask = solid_mask.astype(np.float32)
        mask = _to_tensor(fluid_mask)

        # 将固体速度占位放入 info（自适应维度，默认 0）
        solid_velocity = tuple([0.0] * self.vector_dim)

        # 读取 inlet 边界条件，_parse_inlet_velocity 返回 {'patch': name, 'value': (vx,vy)} 或 None
        inlet_info = self._parse_inlet_velocity(U_path)
        # 只保留 value（如果有），不要把 patch 名传上层
        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 在 x- 侧（j=0）。如果需要更复杂的匹配，可改进。
            inlet_side = 'x-'
            if vals is not None:
                # x-: j_idx=0; x+: j_idx=Ny-1; y+: i_idx=0; y-: i_idx=Nx-1
                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

        # 现在继续 __getitem__ 的后半部分：时间步信息、info 字典填充等
        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}
        # 使用时间目录下的 uniform/time 或 time 文件中的 value 字段作为物理时间（fallback 为目录名数值）
        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

        # 保存两个时间尺度：dt_simulation（origin simulation deltaT）和 dt（writeInterval）
        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
        }

        # 如果 fluid['Re'] 未指定，则用入口速度幅值 * 结构物纵向跨度 / nu 计算 Re
        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

        # 记录 inlet side
        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): # b, f -> f, b
        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()

        """
        # 处理 indices
        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

        # 调用 ffmpeg 合成视频（如果需要）
        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



# 基于多个Dataset实例的包装类，用于多数据集联合训练等场景
# 将多个数据集拼成一个更大的数据集，并视作一个整体
# 在内部如何准确找到样本：将 样本的外部编号 动态映射到 样本所在数据集编号及其在数据集内部的编号
# 可以组装不同的Dataset类，但是这些类必须有统一的的接口和一致的 collate_fn 
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
        # 默认 Dataset 类为 OpenfoamDataset；若 descriptor 为 tuple 则可指定类
        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)

        # expose collate helpers from first dataset for convenience
        if self.datasets_list:
            # expose a collate function from the first dataset; default to OpenfoamDataset.collate_fn
            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, # ✅ 要求 CPU tensor

                         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)

    # Create single OpenfoamDataset instance
    dataset = OpenfoamDataset(
        root_dir=data_path,
        number_of_steps_to_get=number_of_steps_to_get,
        **dataset_kwargs
    )
    
    # Use dataset's collate_fn if not provided
    if collate_fn is None:
        collate_fn = OpenfoamDataset.collate_fn
    
    # Setup distributed sampler if needed
    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
    
    # Setup worker initialization function with seeding
    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()  # number of CUDA devices
    num_workers = min([os.cpu_count() // max(nd, 1), batch_size if batch_size > 1 else 0, num_workers])  # number of workers
    
    # Build DataLoader kwargs
    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, # ✅ 要求 CPU tensor

                          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.')
    
    # Create ConcatDatasetsWrapper instance
    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
    )
    
    # Use wrapper's collate_fn if not provided
    if collate_fn is None:
        collate_fn = getattr(dataset, 'collate_fn', OpenfoamDataset.collate_fn)
    
    # Setup distributed sampler if needed
    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
    
    # Setup worker initialization function with seeding
    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()  # number of CUDA devices
    num_workers = min([os.cpu_count() // max(nd, 1), batch_size if batch_size > 1 else 0, num_workers])  # number of workers
    
    # Build DataLoader kwargs
    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('--visualize', action='store_true', 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") # ✅ NOTE 建议使用cpu模式(在训练循环中手动to(device)), 因为 dataloader 启用 pin-memory 时要求 CPU tensor
    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()))

    # if args.visualize:
    # if True:
    #     os.makedirs(args.save_dir, exist_ok=True)
    #     OpenfoamDataset.visualize(dataset, indices=[args.step], save_dir=args.save_dir)
    #     print(f'  可视化结果保存在 {args.save_dir}')

    #%%
    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✅ 示例执行完毕')