Add files using upload-large-folder tool

DataProcessTools/Conventional_descriptors/bubbleStat_calculator_v4.m

@@ -0,0 +1,158 @@
+%% CALCULATE BUBBLE STATISTICS FROM JSON DATA
+%{
+Description:
+This script reads a JSON file containing manually annotated bubble contours.
+It then calculates key bubble statistics for each image, aggregates the 
+results by heat load, and computes the mean and standard deviation for 
+each heat load condition.
+
+Instructions:
+0. Define the pixel resolution parameter (l_px) accordingly.
+1. Run this script.
+2. A dialog will prompt you to select the JSON data file.
+3. A second dialog will prompt you to select the folder containing the
+   corresponding original images.
+4. The script will process the data and display a results table in the
+   Command Window.
+5. (Optional) Set `save_contour_Mode` to true to save annotated images.
+
+Last modified: 2025/10/08
+Author: Lige Zhang
+Reference: International Journal of Heat and Mass Transfer 255 (2026): 127894.
+%}
+clear; close all; clc
+format long
+
+%% --------------------- USER SETTINGS ---------------------
+% --- Set to true to save images with contours drawn on them ---
+save_contour_Mode = true; 
+
+% --- Physical Constants ---
+% l_px = 32.26e-3;  % Pixel resolution in [mm/pixel] <- IMPORTANT: need to be updated accroding to the dataset!
+l_px = 31.25e-3;
+A_px = l_px^2;    % Area of a single pixel in [mm^2/pixel]
+
+%% --------------------- DATA LOADING ---------------------
+[jsonFileName, jsonPath] = uigetfile('*.json', 'Select the annotated JSON file');
+if isequal(jsonFileName, 0), disp('File selection cancelled.'); return; end
+jsonFile = fullfile(jsonPath, jsonFileName);
+
+imageFolderDIR = uigetdir(jsonPath, 'Select the folder containing the original images');
+if isequal(imageFolderDIR, 0), disp('Folder selection cancelled.'); return; end
+
+jsonText = fileread(jsonFile);
+structData = jsondecode(jsonText);
+imageDataNames = fieldnames(structData);
+
+%% ----------------- BUBBLE STATISTICS CALCULATION -----------------
+bubbleStat = struct;
+disp('Processing images and calculating statistics...');
+
+% --- Create the output directory for contour images ---
+if save_contour_Mode == true
+    save_contour_DIR = fullfile(imageFolderDIR, "BubbleContours");
+    if ~exist(save_contour_DIR, 'dir'), mkdir(save_contour_DIR); end
+end
+
+for i = 1:length(imageDataNames)
+    currentImageKey = imageDataNames{i};
+    currentImageData = structData.(currentImageKey);
+    imageFileName = currentImageData.FileName;
+
+    heatLoadToken = regexp(imageFileName, '_(\d+(\.\d+)?W)_', 'tokens');
+    if isempty(heatLoadToken)
+        warning('Could not parse heat load from filename: %s. Skipping.', imageFileName);
+        continue;
+    end
+    heatLoadStr = heatLoadToken{1}{1};
+    heatLoadFieldName = matlab.lang.makeValidName(['load_' heatLoadStr]);
+    
+    bubbles = currentImageData.Bubbles;
+    bubbleNames = fieldnames(bubbles);
+    numOfBubbles_i = length(bubbleNames);
+    
+    if numOfBubbles_i == 0, continue; end
+
+    allBubbleAreas_i = zeros(numOfBubbles_i, 1); 
+    for j = 1:numOfBubbles_i
+        bubbleName = bubbleNames{j};
+        x_coord = bubbles.(bubbleName).x_coordinate;
+        y_coord = bubbles.(bubbleName).y_coordinate;
+        allBubbleAreas_i(j) = polyarea(x_coord, y_coord) * A_px;
+    end
+    
+    sumAreaBubbles_i = sum(allBubbleAreas_i);
+    avgBubbleArea_i = mean(allBubbleAreas_i);
+    avgBubbleRadius_i = sqrt(avgBubbleArea_i / pi);
+    
+    Img_proc = imread(fullfile(imageFolderDIR, imageFileName));
+    imageTotalArea = size(Img_proc, 1) * size(Img_proc, 2) * A_px;
+    vaporAreaFraction_i = sumAreaBubbles_i / imageTotalArea;
+    
+    if ~isfield(bubbleStat, heatLoadFieldName)
+        bubbleStat.(heatLoadFieldName).NumBubbles = [];
+        bubbleStat.(heatLoadFieldName).AvgArea = [];
+        bubbleStat.(heatLoadFieldName).AvgRadius = [];
+        bubbleStat.(heatLoadFieldName).VaporFraction = [];
+    end
+    
+    bubbleStat.(heatLoadFieldName).NumBubbles(end+1) = numOfBubbles_i;
+    bubbleStat.(heatLoadFieldName).AvgArea(end+1) = avgBubbleArea_i;
+    bubbleStat.(heatLoadFieldName).AvgRadius(end+1) = avgBubbleRadius_i;
+    bubbleStat.(heatLoadFieldName).VaporFraction(end+1) = vaporAreaFraction_i;
+
+    %% --- CORRECTED: Save tightly-cropped image with sanitized filename ---
+    if save_contour_Mode == true
+        % Create a figure but keep it invisible for faster processing
+        fig = figure('Visible', 'off');
+        ax = axes(fig); % Create axes in the figure
+        imshow(Img_proc, 'Parent', ax);
+        hold(ax, 'on');
+        for j = 1:numOfBubbles_i
+            bubbleName = bubbleNames{j};
+            plot(ax, bubbles.(bubbleName).x_coordinate, bubbles.(bubbleName).y_coordinate, 'r--', 'LineWidth', 2);
+        end
+        hold(ax, 'off');
+        
+        % --- FIX 1: Sanitize filename to handle '.' correctly ---
+        [~, base_name, ~] = fileparts(imageFileName);
+        sanitized_name = strrep(base_name, '.', 'd');
+        output_image_path = fullfile(save_contour_DIR, [sanitized_name, '.png']);
+        
+        % --- FIX 2: Use exportgraphics to save without whitespace ---
+        exportgraphics(ax, output_image_path, 'Resolution', 150);
+        
+        close(fig);
+    end
+end
+
+disp('Calculation finished. Summarizing results...');
+%% ------------------- FINAL RESULTS SUMMARY -------------------
+loadNames = fieldnames(bubbleStat);
+numLoads = length(loadNames);
+
+resultsData = zeros(numLoads, 9); 
+for k = 1:numLoads
+    loadName = loadNames{k};
+    loadValueStr = regexp(loadName, '\d+(\.?\d+)?', 'match');
+    loadValue = str2double(loadValueStr{1});
+    
+    resultsData(k, :) = [
+        loadValue, ...
+        mean(bubbleStat.(loadName).NumBubbles), std(bubbleStat.(loadName).NumBubbles), ...
+        mean(bubbleStat.(loadName).AvgArea), std(bubbleStat.(loadName).AvgArea), ...
+        mean(bubbleStat.(loadName).AvgRadius), std(bubbleStat.(loadName).AvgRadius), ...
+        mean(bubbleStat.(loadName).VaporFraction), std(bubbleStat.(loadName).VaporFraction)
+    ];
+end
+
+resultsData = sortrows(resultsData, 1);
+resultsTable = array2table(resultsData, 'VariableNames', {
+    'HeatLoad_W', ...
+    'Mean_NumBubbles', 'StdDev_NumBubbles', ...
+    'Mean_AvgArea_mm2', 'StdDev_AvgArea_mm2', ...
+    'Mean_AvgRadius_mm', 'StdDev_AvgRadius_mm', ...
+    'Mean_VaporFraction', 'StdDev_VaporFraction'
+});
+
+disp(resultsTable);

DataProcessTools/Conventional_descriptors/bubbles_annotator_v6.m

@@ -0,0 +1,230 @@
+%% bubbles_annotator
+%{
+Version: v6
+Description: 
+This script provides a user interface to manually draw bubble contours on a 
+sequence of images. It allows the user to define regions of interest (ROIs) 
+interactively. The contour data for all processed images is then aggregated 
+and can be exported to a single, structured JSON file.
+
+Instructions:
+1. Run this script in MATLAB.
+2. A dialog will appear. Select the folder containing your images.
+3. For each image, a figure window will open.
+   - Left-click to place the vertices of a polygon around a bubble.
+   - Keyboard backspace to undo a click point.
+   - Double-click to finalize the shape. The bubble will be drawn in red.
+4. After each bubble, a dialog will ask for your next action.
+   - 'Define more': Draw another bubble on the same image.
+   - 'Redefine last bubble': Erase the last bubble you just drew.
+   - 'Reset all': Clear all bubbles on the current image and start over.
+   - 'Next image': Move to the next image in the folder.
+   - 'Stop defining': End the annotation session.
+5. At the end, you will be prompted to save all collected data to a JSON file.
+
+Last modified: 2025/10/08
+Author: Lige Zhang
+Reference: International Journal of Heat and Mass Transfer 255 (2026): 127894.
+%}
+%% ------------------- Setup -------------------
+clear, clc
+close all
+format long
+%% --------------------- SCRIPT INITIALIZATION ---------------------
+% Let the user interactively select the folder containing the images
+imageFolderDIR = uigetdir('', 'Select the folder containing your SOURCE images');
+if imageFolderDIR == 0
+    disp('Source folder selection cancelled. Script terminated.');
+    return;
+end
+
+% --- Automatically create a subfolder for the images results ---
+outputFolderDIR = fullfile(imageFolderDIR, 'annotated_results');
+if ~exist(outputFolderDIR, 'dir')
+    mkdir(outputFolderDIR);
+end
+
+% User-configurable settings
+img_type = '.jpg';
+output_json_filename = 'bubble_labeled_data.json';
+
+% Get a list of all image files of the specified type in the folder
+im_files = dir(fullfile(imageFolderDIR, ['*' img_type]));
+if isempty(im_files)
+    disp(['No images of type "' img_type '" found in the source folder.']);
+    return;
+end
+
+% Initialize a master struct to store data for all images
+allFramesData = struct;
+disp(['Found ' num2str(length(im_files)) ' images to process.']);
+
+%% --------------------- MAIN PROCESSING LOOP ---------------------
+for j = 1:length(im_files)
+    
+    imageFileName = im_files(j).name;
+    
+    % Create a custom, MATLAB-compatible struct field name
+    imageName = strrep(imageFileName, img_type, '');
+    imageName = strrep(imageName, '.', 'd');
+    imageName = strrep(imageName, '-', '');
+    if isstrprop(imageName(1), 'digit')
+        imageName = ['Image' imageName];
+    end
+    
+    % Call the interactive drawing function for the current image
+    [stop_processing, imageBubblesData] = drawROI(imageFolderDIR, imageFileName); 
+    
+    % Store the data for the current image in the master struct
+    allFramesData.(imageName) = imageBubblesData;
+    
+    % --- NEW: Save the annotated image ---
+    if ~isempty(fieldnames(imageBubblesData.Bubbles))
+        % Load the original image again
+        I = imread(fullfile(imageFolderDIR, imageFileName));
+        % Create a new figure, but keep it invisible
+        fig_to_save = figure('Visible', 'off');
+        imshow(I);
+        hold on;
+        
+        % Get the names of the bubbles to draw
+        bubble_names = fieldnames(imageBubblesData.Bubbles);
+        for i = 1:length(bubble_names)
+            bubble_data = imageBubblesData.Bubbles.(bubble_names{i});
+            plot(bubble_data.x_coordinate, bubble_data.y_coordinate, 'r--', 'LineWidth', 2);
+        end
+        hold off;
+        
+        % Save the figure to the selected output directory
+        output_image_path = fullfile(outputFolderDIR, imageFileName);
+        saveas(fig_to_save, output_image_path);
+        close(fig_to_save); % Close the invisible figure
+    end
+    
+    % Display progress to the user
+    remaining = length(im_files) - j;
+    disp(['Number of images remaining to process: ' num2str(remaining)])
+    
+    if stop_processing
+        disp('User stopped the process.');
+        break
+    end
+end
+
+%% --------------------- EXPORT TO JSON FILE ---------------------
+if ~isempty(fieldnames(allFramesData))
+    jsonText = jsonencode(allFramesData, "PrettyPrint", true);
+    
+    promptMessage = 'Save the collected bubble data to a JSON file?';
+    titleBarCaption = 'Export Data';
+    button = questdlg(promptMessage, titleBarCaption, 'Save', 'Do Not Save', 'Save');
+    
+    if strcmpi(button, 'Save')
+        % --- CHANGE: Save JSON to the selected output directory ---
+        json_output_path = fullfile(outputFolderDIR, output_json_filename);
+        fileID = fopen(json_output_path, 'w');
+        fprintf(fileID, jsonText);
+        fclose(fileID);
+        disp(['Data successfully saved to: ' json_output_path]);
+    else
+        disp('Data not saved.');
+    end
+end
+
+disp('Annotation process finished.');
+
+
+%% #################### LOCAL FUNCTION: drawROI (Unchanged) ####################
+function [stop_define, imageBubblesData] = drawROI(imageFolderDIR, imageFileName)
+    
+    stop_define = false;
+    ImageFile = fullfile(imageFolderDIR, imageFileName);
+    
+    I = imread(ImageFile);
+    if size(I, 3) == 3
+        I = rgb2gray(I);
+    end
+    
+    regionsOfInterests = struct;
+    
+    fig = figure(1);
+    imshow(I);
+    title({imageFileName, 'Left-click to draw; Keyboard backspace to undo a click point; Double-click to finish a bubble.'}, 'Interpreter', 'none');
+    hold on;
+    
+    while true
+        roi = drawpolygon('Color','g');
+        
+        xi = round(roi.Position(:,1));
+        yi = round(roi.Position(:,2));
+        
+        plot(xi, yi, 'r--', 'LineWidth', 2);
+        
+        num_regions = length(fieldnames(regionsOfInterests)) + 1;
+        bubble_name = ['b' sprintf('%04d', num_regions)];
+        bubble_data = struct('x_coordinate', xi, 'y_coordinate', yi);
+        regionsOfInterests.(bubble_name) = bubble_data;
+
+        promptMessage = 'What to do next?';
+        titleBarCaption = 'Action';
+        choices = {'Define more', 'Redefine last bubble', 'Reset all', 'Next image', 'Stop defining'};
+        
+        [indx, tf] = listdlg('PromptString', promptMessage, ...
+                           'SelectionMode', 'single', ...
+                           'ListString', choices, ...
+                           'Name', titleBarCaption, ...
+                           'ListSize', [250, 120]);
+        
+        if ~tf
+            choice = 'Next image';
+        else
+            choice = choices{indx};
+        end
+        
+        switch choice
+            case 'Define more'
+                continue;
+                
+            case 'Redefine last bubble'
+                disp('Removing the last drawn bubble.');
+                bubble_names = fieldnames(regionsOfInterests);
+                if ~isempty(bubble_names)
+                    last_bubble_name = bubble_names{end};
+                    regionsOfInterests = rmfield(regionsOfInterests, last_bubble_name);
+                    cla;
+                    imshow(I);
+                    title({imageFileName, 'REDEFINE LAST: Left-click to draw, Double-click to finish.'}, 'Interpreter', 'none');
+                    hold on;
+                    remaining_bubble_names = fieldnames(regionsOfInterests);
+                    for i = 1:length(remaining_bubble_names)
+                        bubble_data = regionsOfInterests.(remaining_bubble_names{i});
+                        plot(bubble_data.x_coordinate, bubble_data.y_coordinate, 'r--', 'LineWidth', 2);
+                    end
+                else
+                    disp('No bubbles to redefine.');
+                end
+                continue;
+
+            case 'Reset all'
+                disp('Clearing all bubbles for this image. Please start again.');
+                regionsOfInterests = struct;
+                cla; 
+                imshow(I);
+                title({imageFileName, 'RESET: Left-click to draw, Double-click to finish.'}, 'Interpreter', 'none');
+                continue;
+                
+            case 'Next image'
+                break;
+                
+            case 'Stop defining'
+                stop_define = true;
+                break;
+        end
+    end
+    
+    close(fig);
+    
+    imageBubblesData = struct;
+    imageBubblesData.FileName = imageFileName;
+    imageBubblesData.Bubbles = regionsOfInterests;
+end

DataProcessTools/Generalized_descriptors/PC_calculator_v4.m

@@ -0,0 +1,116 @@
+%% PC_calculator
+%{
+Version: v4
+Description: This code calculate PCs from image data of different heat
+             loads.
+Last modified: 2025/10/07
+Author: Lige Zhang
+Reference: International Journal of Heat and Mass Transfer 255 (2026): 127894.
+%}
+%% ------------------- Setup -------------------
+clear; clc; close all;
+format long;
+%% ------------------- Configuration -------------------
+% Define the main data directory where high-speed images are stored.
+MainData_DIR = "\path\to\your\data"; % <-- IMPORTANT: Set your actual data path here
+
+% Define subfolders for each heat load
+heatLoads = ["15W", "30W"];
+
+% Create a main directory for saving results
+outputDir = fullfile(MainData_DIR, "PC_Results");
+if ~exist(outputDir, 'dir')
+    mkdir(outputDir);
+end
+
+% --- Parameters to define for PCA calculation ---
+totalImages = 3000;           % Total number of images to process per heat load (N)
+imageFileFormat = '%05d.jpg'; % The file name format that the high speed images are saved. 
+numSubsets = 10;              % Number of subsets to divide the data into
+numPCs = 10;                  % Number of principal components to calculate and save
+savePCdata = true;            % Set to true to save results, false to just run
+
+fprintf('PCA Calculation Started...\n');
+
+%% ------------------- Main Processing Loop -------------------
+% Loop over each heat load condition
+for i = 1:length(heatLoads)
+    currentHeatLoad = heatLoads(i);
+    imageDataDir = fullfile(MainData_DIR, currentHeatLoad);
+    fprintf('\nProcessing Heat Load: %s\n', currentHeatLoad);
+    
+    % Create a specific output folder for this heat load's results
+    heatLoadOutputDir = fullfile(outputDir, currentHeatLoad);
+    if ~exist(heatLoadOutputDir, 'dir')
+        mkdir(heatLoadOutputDir);
+    end
+
+    imagesPerSubset = totalImages / numSubsets; % (n)
+
+    % Loop over each of the 10 subsets
+    for s = 1:numSubsets
+        fprintf('  Calculating for Subset %d/%d...\n', s, numSubsets);
+        
+        % --- 1. Load, Resize, and Vectorize Images for the Subset ---
+        
+        % Determine the first and last image index for the current subset
+        firstImageIdx = (s - 1) * imagesPerSubset;
+        lastImageIdx = s * imagesPerSubset - 1;
+
+        % Pre-allocate matrix to hold image data for efficiency
+        % First, read one image to get its dimensions after resizing
+        sampleImPath = fullfile(imageDataDir, sprintf(imageFileFormat, firstImageIdx));
+        I_sample = imread(sampleImPath);
+        
+        [m, n] = size(I_sample); % Get dimensions of the image
+        
+        % Now pre-allocate the data matrix: p-by-n (pixels-by-images)
+        imageData = zeros(m * n, imagesPerSubset);
+        
+        % Load all images for the current subset
+        for k = 1:imagesPerSubset
+            imgIndex = firstImageIdx + (k - 1);
+            imFile = sprintf(imageFileFormat, imgIndex);
+            
+            % Read, convert to double for math, and resize
+            I = double(imread(fullfile(imageDataDir, imFile)));
+            % I_resized = imresize(I, 0.1);
+            
+            % Normalize (0-255 -> 0-1) and flatten into a column vector
+            imageData(:, k) = reshape(I / 255.0, [m * n, 1]);
+        end
+
+        % --- 2. Perform PCA using SVD ---
+        
+        % Calculate the mean image (vector) of the subset
+        meanImageVector = mean(imageData, 2);
+        
+        % Subtract the mean from every image (mean-centering)
+        meanCenteredData = imageData - meanImageVector;
+        
+        % Perform SVD on the transpose of the mean-centered data
+        % 'econ' is crucial for efficiency, as it calculates the "economy size" SVD
+        [U, S, V] = svd(meanCenteredData', 'econ');
+        
+        % --- 3. Calculate and Save Principal Component Scores ---
+        
+        % The PC scores are simply U*S.
+        
+        all_PC_scores = U * S;
+        
+        % Extract the first 10 PCs
+        PC_scores_to_save = all_PC_scores(:, 1:numPCs);
+        
+        % Save the results to a CSV file if requested
+        if savePCdata
+            % Define a descriptive filename
+            fileName = sprintf('Subset_%02d_PCs.csv', s);
+            csvFilePath = fullfile(heatLoadOutputDir, fileName);
+            
+            % Write the matrix of PC scores to the file
+            writematrix(PC_scores_to_save, csvFilePath);
+        end
+    end
+end
+
+fprintf('\nPCA Calculation Complete. Results saved in: %s\n', outputDir);

DataProcessTools/Generalized_descriptors/dominantDescriptor_calculator_v4.m

@@ -0,0 +1,124 @@
+%% dominantDescriptor_calculator
+%{
+Version: v4
+Description: This code calculate dominant frequency and amplitude from PCs
+            of different heat loads.
+Last modified: 2025/10/07
+Author: Lige Zhang
+Reference: International Journal of Heat and Mass Transfer 255 (2026): 127894.
+%}
+%% ------------------- Setup -------------------
+clear; clc; close all;
+format long;
+
+%% ------------------- Configuration -------------------
+% Define the main directory where the "PC_Results" folder is located.
+MainData_DIR = "\path\to\your\data"; % <-- IMPORTANT: Set your path here
+
+% Define subfolders for each heat load 
+heatLoads = ["15W", "30W", "60W", "100W", "150W", "200W", "220W"];
+
+% --- Analysis Parameters ---
+frameRate = 3000;      % Frame rate of the video camera in Hz (fps)
+numSubsets = 10;       % The number of subsets for each heat load
+pcToAnalyze = 1;       % Which Principal Component to analyze. 
+
+% --- Input/Output Directories ---
+% Pointing to the folder created by the PC_calculator script
+pcResultsDir = fullfile(MainData_DIR, "PC_Results"); 
+
+% A new folder will be created to store the Da and Df results
+descriptorDir = fullfile(MainData_DIR, "Dominant_Descriptors");
+if ~exist(descriptorDir, 'dir')
+    mkdir(descriptorDir);
+end
+
+fprintf('Dominant Descriptor Calculation Started...\n');
+
+%% ------------------- Main Processing Loop -------------------
+% Loop over each heat load condition
+for i = 1:length(heatLoads)
+    currentHeatLoad = heatLoads(i);
+    fprintf('\nProcessing Heat Load: %s\n', currentHeatLoad);
+    
+    % This is the folder containing the PC data for the current heat load
+    heatLoadDataDir = fullfile(pcResultsDir, currentHeatLoad);
+
+    % Pre-allocate arrays to store results from the 10 subsets
+    Da_values = zeros(numSubsets, 1);
+    Df_values = zeros(numSubsets, 1);
+
+    % Loop over each of the 10 subsets for the current heat load
+    for s = 1:numSubsets
+        % --- 1. Load the PC data for the current subset ---
+        
+        % Construct the correct filename that was saved by the previous script
+        pc_filename = sprintf('Subset_%02d_PCs.csv', s);
+        pc_filepath = fullfile(heatLoadDataDir, pc_filename);
+        
+        % Check if the file exists before trying to read it
+        if ~exist(pc_filepath, 'file')
+            warning('File not found, skipping: %s', pc_filepath);
+            continue; % Skip to the next subset
+        end
+        
+        all_PC_scores = readmatrix(pc_filepath);
+        
+        % Extract the time series for the PC we want to analyze (e.g., PC1)
+        pc1_time_series = all_PC_scores(:, pcToAnalyze);
+
+        % --- 2. Perform FFT to get the frequency spectrum ---
+        
+        N = length(pc1_time_series); % Number of data points (should be 300)
+        
+        % Perform the Fast Fourier Transform
+        Y = fft(pc1_time_series);
+        
+        % Calculate the single-sided amplitude spectrum
+        P2 = abs(Y / N);
+        P1 = P2(1:floor(N/2)+1);
+        P1(2:end-1) = 2 * P1(2:end-1);
+        
+        % Define the frequency domain vector
+        frequencies = frameRate * (0:(N/2)) / N;
+        
+        % --- 3. Find the Dominant Amplitude (Da) and Frequency (Df) ---
+        
+        % Find the maximum peak in the amplitude spectrum and its index
+        [max_amplitude, index] = max(P1);
+        
+        % Store the results for this subset
+        Da_values(s) = max_amplitude;
+        Df_values(s) = frequencies(index);
+    end
+    
+    % --- 4. Calculate Statistics and Save Results ---
+    
+    % Calculate the mean and standard deviation across the 10 subsets
+    Da_mean = mean(Da_values);
+    Da_std = std(Da_values);
+    Df_mean = mean(Df_values);
+    Df_std = std(Df_values);
+    
+    % Create a clean, organized table for the results
+    resultsTable = table((1:numSubsets)', Da_values, Df_values, ...
+        'VariableNames', {'Subset', 'Dominant_Amplitude_Da', 'Dominant_Frequency_Df'});
+    
+    % Create a summary table for the statistics
+    summaryTable = table(Da_mean, Da_std, Df_mean, Df_std, ...
+        'VariableNames', {'Mean_Da', 'Std_Dev_Da', 'Mean_Df', 'Std_Dev_Df'});
+
+    % Define a descriptive output filename
+    output_filename = sprintf('%s_DominantParams_PC%02d.csv', currentHeatLoad, pcToAnalyze);
+    output_filepath = fullfile(descriptorDir, output_filename);
+    
+    % Write the detailed subset results to the CSV
+    writetable(resultsTable, output_filepath);
+    
+    % Append the summary statistics to the same file
+    writetable(summaryTable, output_filepath, 'WriteMode', 'append', 'WriteVariableNames', true);
+    
+    fprintf('  Done. Results for %s saved.\n', currentHeatLoad);
+end
+
+fprintf('\nDescriptor Calculation Complete. Results saved in: %s\n', descriptorDir);