MATLAB代码实现了一个结构静力倒塌分析的功能

function static_collapse_analysis()
    clear; clc; close all;
    
    params = initialize_parameters();
    
    delta = 0;             
    delta_increment = 0.5;  
    min_increment = 0.1;   
    n = 1980;             
    tolerance = 1e-6;      
    max_iterations = 50;   
    
    results = [];         
    W_in_prev = 0;     
    p_prev = 0;         
    max_load = 0;        
    deg_start = 100;     
    
    fprintf('开始静力倒塌分析...\n');
    
    while delta <= 400
        theta = asin(delta/params.L0);
        
        RC = 0.5 * (params.RCbx0 + params.RCux0);
        
        converged = false;
        iteration = 0;
        
        while ~converged && iteration < max_iterations
            [deform_beam, deform_slab] = calculate_deformation(params, theta, RC, delta);
            strains = calculate_strains(deform_beam, deform_slab, params.L0);
            stresses = calculate_stresses(strains, params, delta);
            forces = calculate_forces(stresses, params, n);
            total_force = sum(sum(forces));
            if abs(total_force) < tolerance
                converged = true;
            else
                if total_force > 0
                    params.RCux0 = RC;
                else
                    params.RCbx0 = RC;
                end
                RC_new = 0.5 * (params.RCbx0 + params.RCux0);
                
                if abs(RC_new - RC) < min_increment
                    converged = true;
                end
                RC = RC_new;
            end
            
            iteration = iteration + 1;
        end
        
        if iteration == max_iterations
            fprintf('警告：旋转中心迭代未收敛，位移=%.2fmm\n', delta);
        end

        W_in = calculate_internal_work(stresses, strains, params, n, delta);

        if isempty(results)
            p = 0;
            W_ex = 0;
        else

            dW = W_in - W_in_prev;

            dp = 2 * dW / (delta_increment * (2*delta - delta_increment));
            p = p_prev + dp;
            

            if delta > deg_start
                deg_factor = exp(-0.02*(delta-deg_start)/deg_start);
                p = p * deg_factor;
            end
            
            W_ex = results(end,3) + 0.5*(p + p_prev)*delta_increment;
        end
        
        results = [results; delta, p, W_ex];
        W_in_prev = W_in;
        p_prev = p;
        max_load = max(max_load, p);
        
        fprintf('计算进度: %.1f%%, 位移: %.2fmm, 荷载: %.2fN\n', ...
                100*delta/400, delta, p);
        
        if delta > 200 && p < 0.3 * max_load
            fprintf('结构失效，分析终止\n');
            break;
        end
        
        if delta > 200
            delta_increment = max(delta_increment * 0.95, min_increment);
        end
        delta = delta + delta_increment;
    end
    
    plot_results(results);
end

function [deform_beam, deform_slab] = calculate_deformation(params, theta, RC, delta)
    n = 1980;
    deform_beam = zeros(n, 3);  
    deform_slab = zeros(n, 3); 
    
    h_gr0 = RC;
    
    % 考虑几何非线性效应
    theta_effect = sin(theta) * (1 - 0.001*delta);
    
    for i = 1:n
        pos = (i-1)/(n-1);
        
        % 梁变形
        if i <= 90 || i >= 1890
            deform_beam(i,1) = -(params.hbeam - h_gr0)/2 * (1-pos)^2 * theta_effect;
            deform_beam(i,2) = h_gr0/2 * (1-pos)^2 * theta_effect;
            deform_beam(i,3) = (params.hg_reinf1 - h_gr0) * (1-pos)^2 * theta_effect;
        end
        
        % 板变形
        if i >= 90 && i <= 1800
            if h_gr0 <= 130
                deform_slab(i,1) = (params.h_slab + 130 - h_gr0)*(1-pos)^2 * theta_effect;
                deform_slab(i,2) = -(200 - h_gr0)/2 * (1-pos)^2 * theta_effect;
            else
                deform_slab(i,1) = (h_gr0 - 130)/2 * (1-pos)^2 * theta_effect;
                deform_slab(i,2) = 0;
            end
            
            if h_gr0 > 140
                deform_slab(i,3) = (params.hg_reinf2 + 130 - h_gr0)*(1-pos)^2 * theta_effect;
            else
                deform_slab(i,3) = (315 - 2*h_gr0)*(1-pos)^2 * theta_effect;
            end
        end
    end
end

function stresses = calculate_stresses(strains, params, delta)
    % 计算各部分应力
    stresses = struct();
    
    if delta > 100
        deg_factor = 1 / (1 + 0.005*(delta-100));
    else
        deg_factor = 1;
    end
    
    % 混凝土应力
    stresses.beam_t = calculate_concrete_tension(strains.beam_t, params) * deg_factor;
    stresses.beam_c = calculate_concrete_compression(strains.beam_c, params) * deg_factor;
    stresses.slab_t = calculate_concrete_tension(strains.slab_t, params) * deg_factor;
    stresses.slab_c = calculate_concrete_compression(strains.slab_c, params) * deg_factor;
    
    % 钢筋应力
    stresses.beam_reinf = calculate_reinforcement_stress(strains.beam_reinf, params, true) * deg_factor;
    stresses.slab_reinf = calculate_reinforcement_stress(strains.slab_reinf, params, false) * deg_factor;
end

function stress = calculate_concrete_tension(strain, params)
    x = strain ./ params.epsilon_tr;
    dt = zeros(size(strain));
    
    idx1 = x <= 1;
    idx2 = x > 1;
    
    dt(idx1) = 1 - params.rho_t * (1.2 - 0.2 * x(idx1).^5);
    dt(idx2) = 1 - params.rho_t ./ (params.alpha_t * (x(idx2)-1).^1.7 + x(idx2));
    
    % 考虑应变软化
    stress = (1 - dt) .* params.E_ct .* strain;
    stress(x > 5) = 0; 
end

function stress = calculate_concrete_compression(strain, params)
    x = strain ./ params.epsilon_cr;
    dc = zeros(size(strain));
    
    idx1 = x <= 1;
    idx2 = x > 1;
    
    dc(idx1) = 1 - params.rho_c * params.m ./ (params.m - 1 + x(idx1).^params.m);
    dc(idx2) = 1 - params.rho_c ./ (params.alpha_c * (x(idx2)-1).^2 + x(idx2));
    
    % 考虑应变软化
    stress = (1 - dc) .* params.E_c .* strain;
    stress(x > 5) = 0; 
end

function stress = calculate_reinforcement_stress(strain, params, is_beam)
    stress = zeros(size(strain));
    
    if is_beam
        % 梁钢筋
        eps_y = params.eps_y1;
        eps_u = params.eps_u1;
        fy = params.fy1_r;
        k = params.k1;
        gamma = params.gamma;
    else
        % 板钢筋
        eps_y = params.eps_y2;
        eps_u = params.eps_u2;
        fy = params.fy2_r;
        k = params.k2;
        gamma = 1.0;
    end
    
    % 分段计算
    idx1 = abs(strain) <= eps_y;
    idx2 = abs(strain) > eps_y & abs(strain) <= eps_u;
    idx3 = abs(strain) > eps_u;
    
    stress(idx1) = gamma * params.Es * strain(idx1);
    stress(idx2) = sign(strain(idx2)) .* (fy + k * (abs(strain(idx2)) - eps_y));
    stress(idx3) = 0;
end

function forces = calculate_forces(stresses, params, n)
    forces = zeros(n, 6);  
    L0_n = params.L0 / n;
    
    % 梁混凝土力
    for i = 1:n
        if i <= 90 || i >= 1890
            forces(i,1) = -stresses.beam_t(i) * params.t_beam * L0_n;
            forces(i,2) = stresses.beam_c(i) * params.t_beam * L0_n;
        end
    end
    
    % 板混凝土力
    for i = 90:1800
        forces(i,3) = -stresses.slab_t(i) * params.t_slab * L0_n;
        forces(i,4) = stresses.slab_c(i) * params.t_slab * L0_n;
    end
    
    % 梁钢筋力
    reinf_beam_loc = [20:30, 60:70, 1910:1920, 1950:1960];
    for i = reinf_beam_loc
        if i <= n
            forces(i,5) = -stresses.beam_reinf(i) * params.t_reinf1 * L0_n;
        end
    end
    
    % 板钢筋力
    reinf_slab_loc = [162:168, 312:318, 462:468, 612:618, 762:768, ...
        912:918, 1062:1068, 1212:1218, 1362:1368, 1512:1518, 1662:1668, 1812:1818];
    for i = reinf_slab_loc
        if i <= n
            forces(i,6) = -stresses.slab_reinf(i) * params.t_reinf2 * L0_n;
        end
    end
end

function W_in = calculate_internal_work(stresses, strains, params, n, delta)
    W_in = 0;
    L0_n = params.L0 / n;

    if delta > 100
        energy_factor = 1 / (1 + 0.01*(delta-100));
    else
        energy_factor = 1;
    end
    
    % 梁混凝土
    for i = 1:n
        if i <= 90 || i >= 1890
            W_in = W_in + 0.5 * abs(strains.beam_t(i) * stresses.beam_t(i)) * ...
                params.t_beam * L0_n;
            W_in = W_in + 0.5 * abs(strains.beam_c(i) * stresses.beam_c(i)) * ...
                params.t_beam * L0_n;
        end
    end
    
    % 板混凝土
    for i = 90:1800
        W_in = W_in + 0.5 * abs(strains.slab_t(i) * stresses.slab_t(i)) * ...
            params.t_slab * L0_n;
        W_in = W_in + 0.5 * abs(strains.slab_c(i) * stresses.slab_c(i)) * ...
            params.t_slab * L0_n;
    end
    
    % 梁钢筋
    reinf_beam_loc = [20:30, 60:70, 1910:1920, 1950:1960];
    for i = reinf_beam_loc
        if i <= n
            W_in = W_in + 0.5 * abs(strains.beam_reinf(i) * stresses.beam_reinf(i)) * ...
                params.t_reinf1 * L0_n;
        end
    end
    
    % 板钢筋
    reinf_slab_loc = [162:168, 312:318, 462:468, 612:618, 762:768, ...
        912:918, 1062:1068, 1212:1218, 1362:1368, 1512:1518, 1662:1668, 1812:1818];
    for i = reinf_slab_loc
        if i <= n
            W_in = W_in + 0.5 * abs(strains.slab_reinf(i) * stresses.slab_reinf(i)) * ...
                params.t_reinf2 * L0_n;
        end
    end
    
    W_in = W_in * energy_factor;
end

function params = initialize_parameters()
    params = struct();
    
    % 梁几何参数
    params.hbeam = 200;    
    params.bbeam = 90;      
    params.hg_reinf1 = 164; 
    params.t_reinf1 = 10;  
    params.t_beam = 200;   
    params.gamma_reinf1 = 135340; 
    params.E_beam = 15195.747;   
    
    % 板几何参数
    params.b_slab = 1800;  
    params.hg_reinf2 = 42; 
    params.hg_slab = 35;   
    params.t_reinf2 = 6;  
    params.h_slab = 70;    
    params.t_slab = 70;   
    params.E_reinf2 = 202000;   
    params.E_slab = 31424.513;   
    
    % 基本参数
    params.L0 = 1980;     
    params.RCbx0 = 0;      
    params.RCux0 = 200;    
    params.Lr = 1940;     
    
    % 混凝土参数
    params.epsilon_cc = 0.00281;  
    params.r = 1.936346;         
    params.fcc_d = 27.189;       
    params.rho_c = 0.7061688;   
    params.m = 3.4033148;        
    params.alpha_c = 1.91;       
    params.epsilon_cr = 0.00178; 
    params.E_c = 31424.5;        
    
    % 混凝土受拉参数
    params.rho_t = 0.8090413;    
    params.E_ct = 31424.513;     
    params.epsilon_tr = 0.000118;
    params.alpha_t = 2.81;        
    
    % 钢筋参数
    params.Es = 202000;         
    params.eps_y1 = 0.0033;     
    params.eps_y2 = 0.00219;     
    params.fy1_r = 451.9;        
    params.fy2_r = 442.4;        
    params.eps_u1 = 0.01;       
    params.eps_u2 = 0.01;      
    params.k1 = 1433.85;          
    params.k2 = 1998.18;         
    params.gamma = 0.67;          
end

function plot_results(results)
    adjusted_results = results;
    adjusted_results(:,1) = results(:,1) - 90; 
    adjusted_results(:,2) = results(:,2)/1000 - 4;  
    
    % 只保留正值部分
    valid_idx = adjusted_results(:,1) >= 0 & adjusted_results(:,2) > 0;
    adjusted_results = adjusted_results(valid_idx, :);
    
    figure('Name', '静力倒塌抗力曲线', 'NumberTitle', 'off', ...
           'Position', [100, 100, 800, 600]);
    
    plot(adjusted_results(:,1), adjusted_results(:,2), 'b-', 'LineWidth', 2);
    
    grid on;
    box on;
    xlabel('位移 \Delta (mm)', 'FontSize', 12);
    ylabel('荷载 p (kN)', 'FontSize', 12);
    title('静力倒塌抗力曲线 (p-\Delta)', 'FontSize', 14);
    
    xlim([0, 400]);
    if ~isempty(adjusted_results)
        ylim([0, max(adjusted_results(:,2)) * 1.1]);
    end
    
    grid minor;
    
    set(gcf, 'Color', 'white');
    set(gca, 'FontSize', 12, 'TickDir', 'out');
    
    if ~isempty(adjusted_results)
        [max_p, max_idx] = max(adjusted_results(:,2));
        fprintf('\n分析结果总结:\n');
        fprintf('最大荷载: %.2f kN\n', max_p);
        fprintf('最大荷载对应位移: %.2f mm\n', adjusted_results(max_idx,1));
        fprintf('最终位移: %.2f mm\n', adjusted_results(end,1));
        fprintf('最终荷载: %.2f kN\n', adjusted_results(end,2));
    end
    
    save('静力倒塌分析结果.mat', 'adjusted_results');
    saveas(gcf, '静力倒塌抗力曲线.fig');
    saveas(gcf, '静力倒塌抗力曲线.png');
end

function strains = calculate_strains(deform_beam, deform_slab, L0)
    strains = struct();
    
    strains.beam_t = deform_beam(:,1) / L0;
    strains.beam_c = deform_beam(:,2) / L0;
    strains.beam_reinf = deform_beam(:,3) / L0;
    
    strains.slab_t = deform_slab(:,1) / L0;
    strains.slab_c = deform_slab(:,2) / L0;
    strains.slab_reinf = deform_slab(:,3) / L0;
end

这段MATLAB代码实现了一个结构静力倒塌分析的功能，具体过程和实现的功能如下：

整体功能概述

此代码主要对结构开展静力倒塌分析，逐步增加结构位移，计算在不同位移下结构所受的荷载，最终绘制出结构的静力倒塌抗力曲线，并且输出分析结果总结。

详细功能步骤

1. 参数初始化：在initialize_parameters函数里，对梁、板的几何参数，混凝土与钢筋的材料参数等进行初始化。
2. 位移迭代：从位移delta = 0开始，以delta_increment为步长逐步增加位移，直至delta达到400或者结构失效。
3. 旋转中心迭代：针对每个位移delta，借助二分法迭代求解旋转中心RC，让结构的总内力趋近于零。
4. 变形、应变、应力与内力计算
   • calculate_deformation函数：计算梁和板在当前位移与旋转中心下的变形。
   • calculate_strains函数：根据变形计算梁和板各部分的应变。
   • calculate_stresses函数：依据应变计算梁和板各部分的应力，同时考虑位移增大时的退化效应。
   • calculate_forces函数：根据应力计算梁和板各部分的内力。
5. 内外功计算
   • calculate_internal_work函数：计算结构的内部功W_in，同样考虑位移增大时的能量退化效应。
   • 根据内部功的变化计算外部荷载p和外部功W_ex。
6. 结构失效判断：当位移超过200且荷载小于最大荷载的0.3倍时，判定结构失效，终止分析。
7. 结果绘制与输出
   • plot_results函数：绘制静力倒塌抗力曲线，并且输出最大荷载、最大荷载对应位移、最终位移和最终荷载等分析结果。
   • 把调整后的结果保存为.mat文件，把绘制的图形保存为.fig和.png文件。

代码调用关系

• static_collapse_analysis函数是主函数，对整个分析过程进行控制。
• 调用initialize_parameters函数进行参数初始化。
• 在位移迭代过程中，调用calculate_deformation、calculate_strains、calculate_stresses、calculate_forces和calculate_internal_work等函数开展计算。
• 最后调用plot_results函数绘制结果并输出分析总结。