function untitled(
)
% 主函数 - 挑流水舌时间序列整体分析（支持.dat和.cas的H5文件）
main_water_jet_analysis_unified(
);
end
function main_water_jet_analysis_unified(
)
% 主分析函数：同时支持.dat和.cas的HDF5时间序列文件
try
% 1. 扩展筛选：同时查找包含".dat"和".cas"的HDF5文件
all_h5_files = dir('*.h5'
);
if isempty(all_h5_files
)
fprintf('当前目录下没有找到任何H5文件！\n'
);
return;
end
time_series_files = [];
for i = 1:length(all_h5_files
)
if contains(all_h5_files(i
).name, '.dat'
) || contains(all_h5_files(i
).name, '.cas'
)
time_series_files = [time_series_files; all_h5_files(i
)]; %#ok<AGROW>
end
end
% 2. 检查筛选结果
if isempty(time_series_files
)
fprintf('未找到文件名包含 ".dat" 或 ".cas" 的HDF5文件！\n'
);
fprintf('当前目录下所有H5文件：\n'
);
for i = 1:length(all_h5_files
)
fprintf(' - %s\n', all_h5_files(i
).name
);
end
fprintf('是否生成模拟时间序列数据？(y/n
)：'
);
response = input('', 's'
);
if strcmpi(response, 'y'
)
generate_simulated_time_series(
);
% 重新筛选
all_h5_files = dir('*.h5'
);
time_series_files = [];
for i = 1:length(all_h5_files
)
if contains(all_h5_files(i
).name, '.dat'
) || contains(all_h5_files(i
).name, '.cas'
)
time_series_files = [time_series_files; all_h5_files(i
)]; %#ok<AGROW>
end
end
else
fprintf('分析终止。\n'
);
return;
end
end
% 3. 文件分类和排序
dat_files = [];
cas_files = [];
for i = 1:length(time_series_files
)
if contains(time_series_files(i
).name, '.dat'
)
dat_files = [dat_files; time_series_files(i
)]; %#ok<AGROW>
elseif contains(time_series_files(i
).name, '.cas'
)
cas_files = [cas_files; time_series_files(i
)]; %#ok<AGROW>
end
end
% 分别对.dat和.cas文件排序
if ~isempty(dat_files
)
[~, sort_idx] = sort({dat_files.name}
);
dat_files = dat_files(sort_idx
);
end
if ~isempty(cas_files
)
[~, sort_idx] = sort({cas_files.name}
);
cas_files = cas_files(sort_idx
);
end
% 4. 显示文件信息
fprintf('\n========================================\n'
);
fprintf(' 挑流水舌时间序列分析（支持.dat和.cas）\n'
);
fprintf('========================================\n'
);
if ~isempty(dat_files
)
fprintf('检测到
%d 个.dat时间序列文件：\n', length(dat_files
));
for i = 1:length(dat_files
)
fprintf(' DAT
%d: %s\n', i, dat_files(i
).name
);
end
end
if ~isempty(cas_files
)
fprintf('检测到
%d 个.cas时间序列文件：\n', length(cas_files
));
for i = 1:length(cas_files
)
fprintf(' CAS
%d: %s\n', i, cas_files(i
).name
);
end
end
% 5. 询问用户如何处理不同类型的文件
fprintf('\n请选择分析模式：\n'
);
fprintf(' 1. 分别分析.dat和.cas文件（生成两个独立报告）\n'
);
fprintf(' 2. 合并分析所有文件（生成一个综合报告）\n'
);
fprintf(' 3. 只分析.dat文件\n'
);
fprintf(' 4. 只分析.cas文件\n'
);
fprintf('请输入选择 (1-4
): '
);
analysis_mode = input('', 's'
);
% 根据选择确定要分析的文件
files_to_analyze = [];
analysis_type = '';
switch analysis_mode
case '1'
% 分别分析
if ~isempty(dat_files
)
fprintf('\n开始分析.dat文件...\n'
);
analyze_file_set(dat_files, 'DAT'
);
end
if ~isempty(cas_files
)
fprintf('\n开始分析.cas文件...\n'
);
analyze_file_set(cas_files, 'CAS'
);
end
return;
case '2'
% 合并分析
files_to_analyze = [dat_files; cas_files];
[~, sort_idx] = sort({files_to_analyze.name}
);
files_to_analyze = files_to_analyze(sort_idx
);
analysis_type = 'COMBINED';
case '3'
% 只分析.dat
if isempty(dat_files
)
fprintf('没有找到.dat文件！\n'
);
return;
end
files_to_analyze = dat_files;
analysis_type = 'DAT';
case '4'
% 只分析.cas
if isempty(cas_files
)
fprintf('没有找到.cas文件！\n'
);
return;
end
files_to_analyze = cas_files;
analysis_type = 'CAS';
otherwise
fprintf('无效选择，使用默认模式（合并分析）\n'
);
files_to_analyze = [dat_files; cas_files];
[~, sort_idx] = sort({files_to_analyze.name}
);
files_to_analyze = files_to_analyze(sort_idx
);
analysis_type = 'COMBINED';
end
% 6. 执行分析
if ~isempty(files_to_analyze
)
fprintf('\n开始分析%s文件...\n', analysis_type
);
analyze_file_set(files_to_analyze, analysis_type
);
else
fprintf('没有找到要分析的文件！\n'
);
end
catch ME
fprintf('\n错误发生：%s\n', ME.message
);
if ~isempty(ME.stack
)
fprintf('在函数：%s\n', ME.stack(1
).name
);
fprintf('行号：
%d\n', ME.stack(1
).line
);
end
fprintf('\n建议：检查H5文件路径或数据结构是否正确\n'
);
end
end
function analyze_file_set(file_set, analysis_type
)
% 分析一组文件
n_time_steps = length(file_set
);
% 显示文件信息
fprintf('\n分析文件列表（%s类型）：\n', analysis_type
);
for i = 1:n_time_steps
fprintf(' 时间步
%d: %s\n', i, file_set(i
).name
);
end
% 自动探测数据路径（使用第一个文件作为模板）
fprintf('\n正在自动探测数据路径结构...\n'
);
first_file = file_set(1
).name;
[detected_paths, all_available_paths] = auto_detect_all_paths(first_file
);
if isempty(detected_paths.coords
)
fprintf('自动探测失败，启动交互式路径选择...\n'
);
detected_paths = interactive_path_selection(first_file, all_available_paths
);
else
fprintf('自动探测成功！\n'
);
fprintf(' 坐标路径: %s\n', detected_paths.coords
);
fprintf(' 速度路径: %s\n', detected_paths.velocity
);
fprintf(' 压力路径: %s\n', detected_paths.pressure
);
fprintf(' 体积分数路径: %s\n', detected_paths.volume_frac
);
% 验证路径有效性
fprintf('\n验证路径有效性...\n'
);
if validate_paths(first_file, detected_paths
)
fprintf('路径验证成功！\n'
);
else
fprintf('路径验证失败，启动交互式路径选择...\n'
);
detected_paths = interactive_path_selection(first_file, all_available_paths
);
end
end
% 确认使用探测到的路径（简化确认流程）
if ~isempty(detected_paths.coords
)
fprintf('\n使用探测到的路径分析所有时间步文件...\n'
);
else
fprintf('无法确定数据路径，分析终止。\n'
);
return;
end
% 预分配存储空间 - 先获取总节点数
fprintf('\n正在计算总数据量...\n'
);
total_nodes = 0;
node_counts = zeros(n_time_steps, 1
);
for time_step = 1:n_time_steps
file_name = file_set(time_step
).name;
data = read_h5_data_with_paths(file_name, detected_paths
);
node_counts(time_step
) = size(data.coordinates, 1
);
total_nodes = total_nodes + node_counts(time_step
);
end
fprintf('总节点数:
%d\n', total_nodes
);
% 预分配数组
all_coordinates = zeros(total_nodes, 3
);
all_velocity = zeros(total_nodes, 3
);
all_pressure = zeros(total_nodes, 1
);
all_volume_fraction = zeros(total_nodes, 1
);
time_step_markers = zeros(n_time_steps, 2
);
file_info = cell(n_time_steps, 5
); % 文件名、类型、节点数、时间步、时间标签
%
整合所有时间序列数据
current_index = 1;
for time_step = 1:n_time_steps
file_name = file_set(time_step
).name;
file_type = get_file_type(file_name
);
fprintf('正在读取时间步
%d/
%d: %s (%s
)\n', time_step, n_time_steps, file_name, file_type
);
% 读取当前时间步数据
data = read_h5_data_with_paths(file_name, detected_paths
);
% 记录当前时间步的节点范围
n_current = node_counts(time_step
);
idx_range = current_index:(current_index + n_current - 1
);
time_step_markers(time_step, :
) = [current_index, current_index + n_current - 1];
% 存储数据到预分配数组
all_coordinates(idx_range, :
) = data.coordinates;
all_velocity(idx_range, :
) = data.velocity;
all_pressure(idx_range
) = data.pressure;
all_volume_fraction(idx_range
) = data.volume_fraction;
current_index = current_index + n_current;
% 存储文件信息
time_label = extract_time_label(file_name, time_step
);
file_info{time_step, 1} = file_name;
file_info{time_step, 2} = file_type;
file_info{time_step, 3} = n_current;
file_info{time_step, 4} = time_step;
file_info{time_step, 5} = time_label;
end
% 创建
整合数据对象
integrated_data = struct(
);
integrated_data.coordinates = all_coordinates;
integrated_data.velocity = all_velocity;
integrated_data.pressure = all_pressure;
integrated_data.volume_fraction = all_volume_fraction;
integrated_data.time_step_markers = time_step_markers;
integrated_data.file_info = file_info;
integrated_data.n_time_steps = n_time_steps;
integrated_data.total_nodes = total_nodes;
integrated_data.time_labels = {file_info{:,5}};
integrated_data.file_types = {file_info{:,2}};
integrated_data.analysis_type = analysis_type;
integrated_data.data_paths = detected_paths;
% 执行
整合分析
fprintf('\n开始时间序列数据分析...\n'
);
integrated_results = analyze_integrated_jet_data(integrated_data
);
% 生成整体报告
fprintf('生成分析报告...\n'
);
generate_unified_time_series_report(integrated_data, integrated_results
);
% 生成可视化分析
fprintf('生成可视化图表...\n'
);
generate_time_series_visualization(integrated_data, integrated_results
);
fprintf('\n========================================\n'
);
fprintf('%s类型时间序列分析完成！\n', analysis_type
);
fprintf('生成文件清单：\n'
);
fprintf(' 1. 分析报告：water_jet_%s_analysis_report.txt\n', lower(analysis_type
));
fprintf(' 2. 可视化图表：time_series_%s_analysis.fig\n', lower(analysis_type
));
fprintf(' 3. 数据汇总：time_series_%s_data.mat\n', lower(analysis_type
));
fprintf('========================================\n'
);
end
function file_type = get_file_type(file_name
)
% 获取文件类型
if contains(file_name, '.dat'
)
file_type = 'DAT';
elseif contains(file_name, '.cas'
)
file_type = 'CAS';
else
file_type = 'UNKNOWN';
end
end
% ==================== 路径自动探测函数 ====================
function [detected_paths, all_paths] = auto_detect_all_paths(file_name
)
% 自动探测所有必要的数据路径
detected_paths = struct('coords', '', 'velocity', '', 'pressure', '', 'volume_frac', ''
);
% 获取所有可用路径
try
info = h5info(file_name
);
all_paths = get_all_h5_datasets(info, ''
);
catch ME
fprintf('读取H5文件信息失败: %s\n', ME.message
);
all_paths = {};
return;
end
if isempty(all_paths
)
fprintf('未找到任何数据路径\n'
);
return;
end
% 显示找到的所有路径（调试用）
fprintf('找到
%d 个数据路径:\n', length(all_paths
));
for i = 1:min(10, length(all_paths
)) % 只显示前10个
fprintf(' %s\n', all_paths{i}
);
end
if length(all_paths
) > 10
fprintf(' ... 还有
%d 个路径\n', length(all_paths
) - 10
);
end
% 定义各种可能的关键词组合（按优先级排序）
coord_keywords = {
{'coordinates', 'coord', 'node', 'position', 'xyz', 'mesh', 'point'}, % 高优先级
{'x', 'y', 'z', 'location'}, % 中优先级
{'geometry', 'grid', 'topology'} % 低优先级
};
velocity_keywords = {
{'velocity', 'vel', 'u', 'v', 'w', 'speed'}, % 高优先级
{'flow', 'vector', 'momentum'}, % 中优先级
{'field', 'data'} % 低优先级
};
pressure_keywords = {
{'pressure', 'press', 'p'}, % 高优先级
{'force', 'stress', 'load'}, % 中优先级
{'scalar', 'field'} % 低优先级
};
volume_frac_keywords = {
{'volume', 'frac', 'fraction', 'phase', 'vof', 'alpha'}, % 高优先级
{'concentration', 'ratio', 'percentage'}, % 中优先级
{'field', 'scalar'} % 低优先级
};
% 探测坐标路径
detected_paths.coords = find_best_path(all_paths, coord_keywords, '坐标'
);
% 探测速度路径
detected_paths.velocity = find_best_path(all_paths, velocity_keywords, '速度'
);
% 探测压力路径
detected_paths.pressure = find_best_path(all_paths, pressure_keywords, '压力'
);
% 探测体积分数路径
detected_paths.volume_frac = find_best_path(all_paths, volume_frac_keywords, '体积分数'
);
end
function best_path = find_best_path(all_paths, keyword_groups, data_type
)
% 根据关键词组找到最佳路径
best_path = '';
best_priority = inf;
% 按优先级顺序搜索
for priority = 1:length(keyword_groups
)
keywords = keyword_groups{priority};
for i = 1:length(all_paths
)
path_lower = lower(all_paths{i}
);
for j = 1:length(keywords
)
if contains(path_lower, lower(keywords{j}
))
% 找到匹配，记录最佳优先级
if priority < best_priority
best_path = all_paths{i};
best_priority = priority;
fprintf(' 找到%s路径: %s (优先级
%d)\n', data_type, best_path, priority
);
end
end
end
end
% 如果找到高优先级的路径，直接返回
if ~isempty(best_path
) && best_priority <= 2
return;
end
end
if isempty(best_path
)
fprintf(' 未找到%s路径\n', data_type
);
end
end
function is_valid = validate_paths(file_name, paths
)
% 验证路径组合是否有效
is_valid = false;
try
% 测试读取坐标数据
coords = h5read(file_name, paths.coords
);
% 确保坐标数据是N×3格式
if size(coords, 2
) ~= 3 && size(coords, 1
) == 3
coords = coords';
end
if size(coords, 2
) ~= 3
fprintf(' 坐标数据维度不正确: %s\n', mat2str(size(coords
)));
return;
end
% 测试读取速度数据
velocity = h5read(file_name, paths.velocity
);
% 确保速度数据是N×3格式
if size(velocity, 2
) ~= 3 && size(velocity, 1
) == 3
velocity = velocity';
end
if size(velocity, 2
) ~= 3
fprintf(' 速度数据维度不正确: %s\n', mat2str(size(velocity
)));
return;
end
% 测试读取压力数据
pressure = h5read(file_name, paths.pressure
);
pressure = pressure(:
); % 确保是列向量
% 测试读取体积分数数据
volume_frac = h5read(file_name, paths.volume_frac
);
volume_frac = volume_frac(:
); % 确保是列向量
% 检查节点数一致性
n_nodes = size(coords, 1
);
if size(velocity, 1
) ~= n_nodes
fprintf(' 速度数据节点数不一致: 坐标=
%d, 速度=
%d\n', n_nodes, size(velocity,1
));
return;
end
if length(pressure
) ~= n_nodes
fprintf(' 压力数据节点数不一致: 坐标=
%d, 压力=
%d\n', n_nodes, length(pressure
));
return;
end
if length(volume_frac
) ~= n_nodes
fprintf(' 体积分数数据节点数不一致: 坐标=
%d, 体积分数=
%d\n', n_nodes, length(volume_frac
));
return;
end
is_valid = true;
fprintf(' 路径验证通过: 所有数据维度正确，节点数=
%d\n', n_nodes
);
catch ME
fprintf(' 路径验证失败: %s\n', ME.message
);
end
end
% ==================== 交互式路径选择 ====================
function selected_paths = interactive_path_selection(file_name, all_paths
)
% 交互式路径选择界面
fprintf('\n========================================\n'
);
fprintf('交互式路径选择 - %s\n', file_name
);
fprintf('========================================\n'
);
selected_paths = struct('coords', '', 'velocity', '', 'pressure', '', 'volume_frac', ''
);
% 显示所有可用路径
if isempty(all_paths
)
fprintf('没有可用的数据路径！\n'
);
return;
end
fprintf('\n可用数据路径列表:\n'
);
for i = 1:length(all_paths
)
fprintf(' [%2d] %s\n', i, all_paths{i}
);
end
% 选择坐标路径
fprintf('\n请选择坐标数据路径（包含X,Y,Z坐标）:\n'
);
selected_paths.coords = select_path_interactive(all_paths, '坐标'
);
% 选择速度路径
fprintf('\n请选择速度数据路径（包含Vx,Vy,Vz分量）:\n'
);
selected_paths.velocity = select_path_interactive(all_paths, '速度'
);
% 选择压力路径
fprintf('\n请选择压力数据路径:\n'
);
selected_paths.pressure = select_path_interactive(all_paths, '压力'
);
% 选择体积分数路径
fprintf('\n请选择体积分数数据路径:\n'
);
selected_paths.volume_frac = select_path_interactive(all_paths, '体积分数'
);
% 验证选择的路径
fprintf('\n验证选择的路径...\n'
);
if validate_paths(file_name, selected_paths
)
fprintf('路径选择完成！\n'
);
else
fprintf('路径验证失败，请重新选择\n'
);
selected_paths = interactive_path_selection(file_name, all_paths
);
end
end
function selected_path = select_path_interactive(all_paths, data_type
)
% 交互式选择单个路径
while true
fprintf('输入路径编号 (1-
%d) 或输入完整路径: ', length(all_paths
));
user_input = input('', 's'
);
% 检查是否为数字选择
choice_num = str2double(user_input
);
if ~isnan(choice_num
) && choice_num >= 1 && choice_num <= length(all_paths
)
selected_path = all_paths{choice_num};
fprintf('已选择: %s\n', selected_path
);
break;
else
% 检查是否为有效路径
if ~isempty(user_input
)
selected_path = user_input;
fprintf('已输入: %s\n', selected_path
);
break;
else
fprintf('输入无效，请重新选择\n'
);
end
end
end
end
% ==================== 数据读取函数 ====================
function data = read_h5_data_with_paths(file_name, paths
)
% 使用指定路径读取HDF5文件数据
data = struct(
);
data.file_name = file_name;
try
% 读取坐标数据
coords_data = h5read(file_name, paths.coords
);
% 确保坐标数据是N×3格式
if size(coords_data, 2
) ~= 3 && size(coords_data, 1
) == 3
coords_data = coords_data';
end
if size(coords_data, 2
) ~= 3
error('坐标数据维度不正确，期望N×3，实际为%s', mat2str(size(coords_data
)));
end
data.coordinates = coords_data;
% 读取速度数据
vel_data = h5read(file_name, paths.velocity
);
% 确保速度数据是N×3格式
if size(vel_data, 2
) ~= 3 && size(vel_data, 1
) == 3
vel_data = vel_data';
end
if size(vel_data, 2
) ~= 3
error('速度数据维度不正确，期望N×3，实际为%s', mat2str(size(vel_data
)));
end
data.velocity = vel_data;
% 读取压力数据
press_data = h5read(file_name, paths.pressure
);
data.pressure = press_data(:
); % 确保是列向量
% 读取体积分数数据
vol_data = h5read(file_name, paths.volume_frac
);
data.volume_fraction = vol_data(:
); % 确保是列向量
% 验证数据一致性
n_nodes = size(data.coordinates, 1
);
if size(data.velocity, 1
) ~= n_nodes
error('速度数据节点数(
%d)与坐标节点数(
%d)不匹配', size(data.velocity,1
), n_nodes
);
end
if length(data.pressure
) ~= n_nodes
error('压力数据节点数(
%d)与坐标节点数(
%d)不匹配', length(data.pressure
), n_nodes
);
end
if length(data.volume_fraction
) ~= n_nodes
error('体积分数数据节点数(
%d)与坐标节点数(
%d)不匹配', length(data.volume_fraction
), n_nodes
);
end
catch ME
error('读取文件 %s 失败: %s', file_name, ME.message
);
end
end
% ==================== 时间标签提取函数 ====================
function time_label = extract_time_label(file_name, time_step
)
% 从文件名中提取时间标签
% 尝试从文件名中提取数字作为时间
numbers = regexp(file_name, '\d+', 'match'
);
if ~isempty(numbers
)
% 使用找到的最后一个数字作为时间
time_value = str2double(numbers{end}
);
time_label =
sprintf('t=%.2f', time_value
);
else
% 如果没有数字，使用时间步序号
time_label =
sprintf('Step
%d', time_step
);
end
end
% ==================== 分析函数 ====================
function integrated_results = analyze_integrated_jet_data(integrated_data
)
% 分析
整合的挑流数据
integrated_results = struct(
);
% 基本统计信息
integrated_results.total_nodes = integrated_data.total_nodes;
integrated_results.n_time_steps = integrated_data.n_time_steps;
% 水相节点统计
water_mask = integrated_data.volume_fraction > 0.5;
integrated_results.water_nodes = sum(water_mask
);
integrated_results.water_ratio = integrated_results.water_nodes / integrated_results.total_nodes * 100;
% 速度统计
speed = sqrt(sum(integrated_data.velocity.^2, 2
));
integrated_results.avg_speed = mean(speed
);
integrated_results.max_speed = max(speed
);
integrated_results.min_speed = min(speed
);
integrated_results.speed_std = std(speed
);
% 压力统计
integrated_results.avg_pressure = mean(integrated_data.pressure
);
integrated_results.max_pressure = max(integrated_data.pressure
);
integrated_results.min_pressure = min(integrated_data.pressure
);
integrated_results.pressure_std = std(integrated_data.pressure
);
% 水舌形态统计
if any(water_mask
)
water_coords = integrated_data.coordinates(water_mask, :
);
integrated_results.jet_length = max(water_coords(:,1
)) - min(water_coords(:,1
));
integrated_results.jet_height = max(water_coords(:,2
)) - min(water_coords(:,2
));
integrated_results.jet_width = max(water_coords(:,3
)) - min(water_coords(:,3
));
integrated_results.jet_centroid = mean(water_coords, 1
);
else
integrated_results.jet_length = 0;
integrated_results.jet_height = 0;
integrated_results.jet_width = 0;
integrated_results.jet_centroid = [0, 0, 0];
end
% 时间序列演化分析
integrated_results.time_evolution = analyze_time_evolution(integrated_data
);
% 空间分布分析
integrated_results.spatial_analysis = analyze_spatial_distribution(integrated_data
);
% 相关性分析
integrated_results.correlation_analysis = analyze_correlations(integrated_data
);
end
function time_evolution = analyze_time_evolution(integrated_data
)
% 分析时间序列演化特征
time_evolution = struct(
);
n_steps = integrated_data.n_time_steps;
% 预分配数组
time_evolution.avg_speed = zeros(n_steps, 1
);
time_evolution.water_ratio = zeros(n_steps, 1
);
time_evolution.jet_length = zeros(n_steps, 1
);
time_evolution.jet_height = zeros(n_steps, 1
);
time_evolution.jet_width = zeros(n_steps, 1
);
time_evolution.total_nodes = zeros(n_steps, 1
);
for t = 1:n_steps
start_idx = integrated_data.time_step_markers(t, 1
);
end_idx = integrated_data.time_step_markers(t, 2
);
% 当前时间步数据
coords_t = integrated_data.coordinates(start_idx:end_idx, :
);
velocity_t = integrated_data.velocity(start_idx:end_idx, :
);
volume_frac_t = integrated_data.volume_fraction(start_idx:end_idx
);
% 计算各指标
speed_t = sqrt(sum(velocity_t.^2, 2
));
time_evolution.avg_speed(t
) = mean(speed_t
);
time_evolution.water_ratio(t
) = sum(volume_frac_t > 0.5
) / length(volume_frac_t
) * 100;
time_evolution.total_nodes(t
) = length(volume_frac_t
);
% 水舌形态
water_mask_t = volume_frac_t > 0.5;
if any(water_mask_t
)
water_coords_t = coords_t(water_mask_t, :
);
time_evolution.jet_length(t
) = max(water_coords_t(:,1
)) - min(water_coords_t(:,1
));
time_evolution.jet_height(t
) = max(water_coords_t(:,2
)) - min(water_coords_t(:,2
));
time_evolution.jet_width(t
) = max(water_coords_t(:,3
)) - min(water_coords_t(:,3
));
else
time_evolution.jet_length(t
) = 0;
time_evolution.jet_height(t
) = 0;
time_evolution.jet_width(t
) = 0;
end
end
% 计算变化趋势
if n_steps > 1
time_evolution.speed_trend = polyfit(1:n_steps, time_evolution.avg_speed', 1
);
time_evolution.water_ratio_trend = polyfit(1:n_steps, time_evolution.water_ratio', 1
);
time_evolution.jet_length_trend = polyfit(1:n_steps, time_evolution.jet_length', 1
);
time_evolution.jet_height_trend = polyfit(1:n_steps, time_evolution.jet_height', 1
);
else
time_evolution.speed_trend = [0, 0];
time_evolution.water_ratio_trend = [0, 0];
time_evolution.jet_length_trend = [0, 0];
time_evolution.jet_height_trend = [0, 0];
end
end
function spatial_analysis = analyze_spatial_distribution(integrated_data
)
% 分析空间分布特征
spatial_analysis = struct(
);
water_mask = integrated_data.volume_fraction > 0.5;
water_coords = integrated_data.coordinates(water_mask, :
);
if ~isempty(water_coords
)
spatial_analysis.x_range = [min(water_coords(:,1
)), max(water_coords(:,1
))];
spatial_analysis.y_range = [min(water_coords(:,2
)), max(water_coords(:,2
))];
spatial_analysis.z_range = [min(water_coords(:,3
)), max(water_coords(:,3
))];
spatial_analysis.centroid_trajectory = calculate_centroid_trajectory(integrated_data
);
else
spatial_analysis.x_range = [0, 0];
spatial_analysis.y_range = [0, 0];
spatial_analysis.z_range = [0, 0];
spatial_analysis.centroid_trajectory = [];
end
end
function centroid_trajectory = calculate_centroid_trajectory(integrated_data
)
% 计算水舌质心随时间的变化轨迹
n_steps = integrated_data.n_time_steps;
centroid_trajectory = zeros(n_steps, 3
);
for t = 1:n_steps
start_idx = integrated_data.time_step_markers(t, 1
);
end_idx = integrated_data.time_step_markers(t, 2
);
coords_t = integrated_data.coordinates(start_idx:end_idx, :
);
volume_frac_t = integrated_data.volume_fraction(start_idx:end_idx
);
water_mask_t = volume_frac_t > 0.5;
if any(water_mask_t
)
water_coords_t = coords_t(water_mask_t, :
);
centroid_trajectory(t, :
) = mean(water_coords_t, 1
);
else
centroid_trajectory(t, :
) = [0, 0, 0];
end
end
end
function correlation_analysis = analyze_correlations(integrated_data
)
% 分析各物理量之间的相关性
correlation_analysis = struct(
);
water_mask = integrated_data.volume_fraction > 0.5;
if sum(water_mask
) > 1
water_coords = integrated_data.coordinates(water_mask, :
);
water_velocity = integrated_data.velocity(water_mask, :
);
water_pressure = integrated_data.pressure(water_mask
);
speed = sqrt(sum(water_velocity.^2, 2
));
% 计算相关系数
[correlation_analysis.speed_pressure_r, correlation_analysis.speed_pressure_p] = ...
corr(speed, water_pressure
);
[correlation_analysis.height_speed_r, correlation_analysis.height_speed_p] = ...
corr(water_coords(:,2
), speed
);
[correlation_analysis.length_pressure_r, correlation_analysis.length_pressure_p] = ...
corr(water_coords(:,1
), water_pressure
);
else
correlation_analysis.speed_pressure_r = 0;
correlation_analysis.speed_pressure_p = 1;
correlation_analysis.height_speed_r = 0;
correlation_analysis.height_speed_p = 1;
correlation_analysis.length_pressure_r = 0;
correlation_analysis.length_pressure_p = 1;
end
end
% ==================== 报告生成函数 ====================
function generate_unified_time_series_report(integrated_data, integrated_results
)
% 生成针对时间序列的整体分析报告
report_lines = {};
analysis_type = integrated_data.analysis_type;
% 报告标题
report_lines{end+1} = '==================================================';
report_lines{end+1} =
sprintf(' 挑流水舌时间序列分析报告 (%s
)', analysis_type
);
report_lines{end+1} = '==================================================';
report_lines{end+1} = '';
report_lines{end+1} =
sprintf('分析时间：%s', datestr(now
));
report_lines{end+1} =
sprintf('分析类型：%s', analysis_type
);
report_lines{end+1} =
sprintf('时间步数量：
%d', integrated_data.n_time_steps
);
report_lines{end+1} =
sprintf('总数据节点数：
%d', integrated_results.total_nodes
);
report_lines{end+1} = '';
% 数据路径信息
report_lines{end+1} = '一、数据路径配置';
report_lines{end+1} = '----------------------------------------';
report_lines{end+1} =
sprintf('坐标数据路径：%s', integrated_data.data_paths.coords
);
report_lines{end+1} =
sprintf('速度数据路径：%s', integrated_data.data_paths.velocity
);
report_lines{end+1} =
sprintf('压力数据路径：%s', integrated_data.data_paths.pressure
);
report_lines{end+1} =
sprintf('体积分数路径：%s', integrated_data.data_paths.volume_frac
);
report_lines{end+1} = '';
% 文件列表
report_lines{end+1} = '二、时间序列文件';
report_lines{end+1} = '----------------------------------------';
for t = 1:integrated_data.n_time_steps
report_lines{end+1} =
sprintf('时间步
%d: %s (%s, %s,
%d节点
)', t, ...
integrated_data.file_info{t,1}, integrated_data.file_info{t,2}, ...
integrated_data.file_info{t,5}, integrated_data.file_info{t,3}
);
end
report_lines{end+1} = '';
% 整体统计
report_lines{end+1} = '三、整体统计信息';
report_lines{end+1} = '----------------------------------------';
report_lines{end+1} =
sprintf('水相节点总数：
%d (%.1f%%
)', ...
integrated_results.water_nodes, integrated_results.water_ratio
);
report_lines{end+1} =
sprintf('平均水流速度：%.2f ± %.2f m/s', ...
integrated_results.avg_speed, integrated_results.speed_std
);
report_lines{end+1} =
sprintf('速度范围：[%.2f, %.2f] m/s', ...
integrated_results.min_speed, integrated_results.max_speed
);
report_lines{end+1} =
sprintf('平均压力：%.2f ± %.2f Pa', ...
integrated_results.avg_pressure, integrated_results.pressure_std
);
report_lines{end+1} = '';
% 时间演化分析
report_lines{end+1} = '四、时间演化特征';
report_lines{end+1} = '----------------------------------------';
te = integrated_results.time_evolution;
report_lines{end+1} =
sprintf('速度变化趋势：y = %.4fx + %.4f', ...
te.speed_trend(1
), te.speed_trend(2
));
report_lines{end+1} =
sprintf('水相占比趋势：y = %.4fx + %.4f', ...
te.water_ratio_trend(1
), te.water_ratio_trend(2
));
report_lines{end+1} =
sprintf('水舌长度趋势：y = %.4fx + %.4f', ...
te.jet_length_trend(1
), te.jet_length_trend(2
));
report_lines{end+1} =
sprintf('水舌高度趋势：y = %.4fx + %.4f', ...
te.jet_height_trend(1
), te.jet_height_trend(2
));
report_lines{end+1} = '';
% 详细时间步数据
report_lines{end+1} = '五、各时间步详细数据';
report_lines{end+1} = '----------------------------------------';
report_lines{end+1} = '时间步 文件类型 时间标签 平均速度(m/s
) 水相占比(%
) 水舌长度(m
) 水舌高度(m
) 节点数';
report_lines{end+1} = '-------------------------------------------------------------------------------------------------';
te = integrated_results.time_evolution;
for t = 1:integrated_data.n_time_steps
report_lines{end+1} =
sprintf('%4d %-6s %-8s %10.2f %9.1f %10.2f %10.2f %8d', ...
t, integrated_data.file_types{t}, integrated_data.time_labels{t}, ...
te.avg_speed(t
), te.water_ratio(t
), te.jet_length(t
), te.jet_height(t
), te.total_nodes(t
));
end
report_lines{end+1} = '';
report_lines{end+1} = '==================================================';
report_lines{end+1} = ' 报告结束';
report_lines{end+1} = '==================================================';
% 保存报告
report_filename =
sprintf('water_jet_%s_analysis_report.txt', lower(analysis_type
));
fid = fopen(report_filename, 'w', 'n', 'UTF-8'
);
if fid == -1
fprintf('无法创建报告文件：%s\n', report_filename
);
return;
end
for i = 1:length(report_lines
)
fprintf(fid, '%s\n', report_lines{i}
);
end
fclose(fid
);
fprintf('分析报告已保存至：%s\n', report_filename
);
end
% ==================== 可视化函数 ====================
function generate_time_series_visualization(integrated_data, integrated_results
)
% 生成时间序列可视化分析
analysis_type = integrated_data.analysis_type;
fig = figure('Position', [100, 50, 1400, 900], ...
'Name',
sprintf('挑流水舌时间序列分析 (%s
)', analysis_type
), ...
'NumberTitle', 'off'
);
% 1. 时间演化趋势
subplot(2, 3, 1
);
te = integrated_results.time_evolution;
plot(1:integrated_data.n_time_steps, te.avg_speed, 'b-o', 'LineWidth', 2
);
xlabel('时间步'
); ylabel('平均速度 (m/s
)'
);
title('速度随时间演化'
);
grid on;
subplot(2, 3, 2
);
plot(1:integrated_data.n_time_steps, te.water_ratio, 'g-o', 'LineWidth', 2
);
xlabel('时间步'
); ylabel('水相占比 (%
)'
);
title('水相占比随时间演化'
);
grid on;
subplot(2, 3, 3
);
plot(1:integrated_data.n_time_steps, te.jet_length, 'r-o', 'LineWidth', 2
);
xlabel('时间步'
); ylabel('水舌长度 (m
)'
);
title('水舌长度随时间演化'
);
grid on;
subplot(2, 3, 4
);
plot(1:integrated_data.n_time_steps, te.jet_height, 'm-o', 'LineWidth', 2
);
xlabel('时间步'
); ylabel('水舌高度 (m
)'
);
title('水舌高度随时间演化'
);
grid on;
% 2. 质心轨迹
subplot(2, 3, 5
);
centroid_traj = integrated_results.spatial_analysis.centroid_trajectory;
if ~isempty(centroid_traj
) && size(centroid_traj, 1
) > 1
plot(centroid_traj(:,1
), centroid_traj(:,2
), 'k-s', 'LineWidth', 2, 'MarkerSize', 6
);
xlabel('X (m
)'
); ylabel('Y (m
)'
);
title('水舌质心运动轨迹'
);
grid on;
% 添加时间步标注
for t = 1:size(centroid_traj, 1
)
text(centroid_traj(t,1
), centroid_traj(t,2
),
sprintf('t=
%d', t
), ...
'FontSize', 8, 'HorizontalAlignment', 'center'
);
end
else
text(0.5, 0.5, '无足够数据绘制质心轨迹', 'HorizontalAlignment', 'center', 'Units', 'normalized'
);
title('水舌质心运动轨迹'
);
end
% 3. 最终时刻水舌分布
subplot(2, 3, 6
);
% 获取最后一个时间步的数据
last_start = integrated_data.time_step_markers(end, 1
);
last_end = integrated_data.time_step_markers(end, 2
);
last_coords = integrated_data.coordinates(last_start:last_end, :
);
last_volume_frac = integrated_data.volume_fraction(last_start:last_end
);
water_mask = last_volume_frac > 0.5;
if any(water_mask
)
water_coords = last_coords(water_mask, :
);
scatter(water_coords(:,1
), water_coords(:,2
), 10, 'filled', 'MarkerFaceAlpha', 0.6
);
xlabel('X (m
)'
); ylabel('Y (m
)'
);
title('最终时刻水舌分布'
);
grid on;
else
text(0.5, 0.5, '无足够数据绘制水舌分布', 'HorizontalAlignment', 'center', 'Units', 'normalized'
);
title('最终时刻水舌分布'
);
end
% 保存图表和数据
fig_filename =
sprintf('time_series_%s_analysis.fig', lower(analysis_type
));
data_filename =
sprintf('time_series_%s_data.mat', lower(analysis_type
));
try
saveas(fig, fig_filename
);
save(data_filename, 'integrated_data', 'integrated_results'
);
fprintf('图表已保存至：%s\n', fig_filename
);
fprintf('数据已保存至：%s\n', data_filename
);
catch ME
fprintf('保存文件时
出错：%s\n', ME.message
);
end
% 关闭图形以释放内存
close(fig
);
end
% ==================== 辅助函数 ====================
function all_datasets = get_all_h5_datasets(h5_info, current_path
)
% 递归获取H5文件中所有数据集的完整路径
if nargin < 2
current_path = '';
end
all_datasets = {};
% 构建当前组的完整路径
if ~isempty(h5_info.Name
)
if isempty(current_path
)
current_group = ['/' h5_info.Name];
else
current_group = [current_path '/' h5_info.Name];
end
else
current_group = current_path;
end
% 添加当前组中的数据集的完整路径
if isfield(h5_info, 'Datasets'
) && ~isempty(h5_info.Datasets
)
for i = 1:length(h5_info.Datasets
)
if isempty(current_group
)
full_path = ['/' h5_info.Datasets(i
).Name];
else
full_path = [current_group '/' h5_info.Datasets(i
).Name];
end
all_datasets{end+1} = full_path; %#ok<AGROW>
end
end
% 递归处理子组
if isfield(h5_info, 'Groups'
) && ~isempty(h5_info.Groups
)
for i = 1:length(h5_info.Groups
)
sub_datasets = get_all_h5_datasets(h5_info.Groups(i
), current_group
);
all_datasets = [all_datasets, sub_datasets]; %#ok<AGROW>
end
end
end
% ==================== 模拟数据生成函数 ====================
function generate_simulated_time_series(
)
% 生成含.dat和.cas的模拟时间序列H5文件
n_time_steps = 8;
fprintf('正在生成
%d 个模拟时间序列H5文件（包含.dat和.cas）...\n', n_time_steps
);
for t = 1:n_time_steps
% 交替生成.dat和.cas文件
if mod(t, 2
) == 1
file_name =
sprintf('jet_data_%03d.dat.h5', t
);
else
file_name =
sprintf('jet_case_%03d.cas.h5', t
);
end
n_nodes = 8000 + t * 500;
coords = generate_simulated_coordinates(t
);
velocity = generate_simulated_velocity(n_nodes, t
);
pressure = generate_simulated_pressure(n_nodes, t
);
volume_fraction = generate_simulated_volume_fraction(n_nodes, t
);
% 确保目录存在
if exist(file_name, 'file'
)
delete(file_name
);
end
% 创建H5文件并写入数据
h5create(file_name, '/Mesh/Nodes', size(coords'
));
h5write(file_name, '/Mesh/Nodes', coords'
);
h5create(file_name, '/Flow/FieldData/Velocity', size(velocity'
));
h5write(file_name, '/Flow/FieldData/Velocity', velocity'
);
h5create(file_name, '/Flow/FieldData/Pressure', size(pressure
));
h5write(file_name, '/Flow/FieldData/Pressure', pressure
);
h5create(file_name, '/Flow/FieldData/VolumeFraction', size(volume_fraction
));
h5write(file_name, '/Flow/FieldData/VolumeFraction', volume_fraction
);
fprintf(' 生成文件：%s\n', file_name
);
end
fprintf('模拟时间序列文件生成完成！\n'
);
end
function coords = generate_simulated_coordinates(varargin
)
if nargin == 0
t = 1;
else
t = varargin{1};
end
n_nodes = 8000 + t * 500;
coords = zeros(n_nodes, 3
);
x_offset = (t-1
) * 5;
x_base = linspace(x_offset, 70 + x_offset, n_nodes
)';
y_base = 50 + 17 * (1 - exp(-(x_base - x_offset
)/30
)) + (t-1
) * 0.5;
z_base = linspace(0, 6 + (t-1
)*0.3, n_nodes
)';
coords(:,1
) = x_base + randn(n_nodes, 1
) * 2;
coords(:,2
) = y_base + randn(n_nodes, 1
) * 1;
coords(:,3
) = z_base + randn(n_nodes, 1
) * 0.5;
coords(:,1
) = max(x_offset, min(70 + x_offset, coords(:,1
)));
coords(:,2
) = max(50, min(67 + t, coords(:,2
)));
coords(:,3
) = max(0, min(6 + t, coords(:,3
)));
end
function velocity = generate_simulated_velocity(n_nodes, varargin
)
if nargin < 2
t = 1;
else
t = varargin{1};
end
velocity = zeros(n_nodes, 3
);
speed_factor = 1 + (t-1
)*0.05;
base_speed = 25 * speed_factor + randn(n_nodes, 1
) * 3;
velocity(:,1
) = base_speed .* (0.8 + 0.4 * rand(n_nodes, 1
));
velocity(:,2
) = randn(n_nodes, 1
) * 2;
velocity(:,3
) = randn(n_nodes, 1
) * 1;
speed = sqrt(sum(velocity.^2, 2
));
speed = max(20 * speed_factor, min(35 * speed_factor, speed
));
velocity = velocity ./ (speed + eps
) .* speed;
end
function pressure = generate_simulated_pressure(n_nodes, varargin
)
if nargin < 2
t = 1;
else
t = varargin{1};
end
pressure_offset = (t-1
) * 1000;
pressure = 101325 + pressure_offset + randn(n_nodes, 1
) * 5000;
pressure = max(90000 + pressure_offset, min(110000 + pressure_offset, pressure
));
end
function volume_fraction = generate_simulated_volume_fraction(n_nodes, varargin
)
if nargin < 2
t = 1;
else
t = varargin{1};
end
volume_fraction = zeros(n_nodes, 1
);
water_ratio = 0.6 + (t-1
)*0.03;
water_ratio = min(0.9, water_ratio
);
water_indices = 1:floor(n_nodes * water_ratio
);
volume_fraction(water_indices
) = 0.9 + rand(length(water_indices
), 1
) * 0.1;
air_indices = (floor(n_nodes * water_ratio
) + 1
):n_nodes;
volume_fraction(air_indices
) = rand(length(air_indices
), 1
) * 0.1;
volume_fraction = min(1, max(0, volume_fraction
));
end
这串
代码怎么样，能实现吗，哪里需要改进
本文介绍了一个使用sprintf函数时常见的问题，即当编译器无法识别%d类型的数据时可能导致的输出错误，并提供了一种通过类型强制转换来解决问题的方法。
扫一扫
1097
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
