梁非线性动力学方程MATLAB编程实现

梁非线性动力学方程MATLAB编程实现，适用于动力学分析：

%% 梁非线性动力学分析系统
% 包含几何非线性、材料非线性和大变形分析
clear; close all; clc;

%% 1. 参数设置
% 梁的几何参数
L = 1.0;            % 梁长度 (m)
b = 0.02;           % 宽度 (m)
h = 0.005;          % 高度 (m)
A = b * h;          % 横截面积 (m²)
I = b * h^3 / 12;   % 截面惯性矩 (m⁴)

% 材料参数
E = 2.1e11;         % 弹性模量 (Pa)
rho = 7800;         % 密度 (kg/m³)
nu = 0.3;           % 泊松比
G = E / (2*(1+nu)); % 剪切模量

% 边界条件类型
% 1: 简支-简支, 2: 固支-固支, 3: 固支-自由, 4: 固支-简支
bc_type = 1;

% 加载条件
P = 1000;           % 集中载荷 (N)
q = 5000;           % 分布载荷 (N/m)
load_type = 'point'; % 'point'或'distributed'

% 非线性分析选项
include_geometric_nonlinearity = true;  % 包含几何非线性
include_material_nonlinearity = false;  % 包含材料非线性
large_deflection = false;               % 大变形分析

% 时间参数
T_total = 2.0;      % 总时间 (s)
dt = 0.001;         % 时间步长 (s)
t = 0:dt:T_total;   % 时间向量
Nt = length(t);     % 时间步数

% 空间离散
N_elements = 20;    % 单元数量
N_nodes = N_elements + 1; % 节点数量
dx = L / N_elements;% 单元长度
x_nodes = linspace(0, L, N_nodes); % 节点坐标

% 自由度: 每个节点有横向位移w和转角θ
dof_per_node = 2;
total_dof = N_nodes * dof_per_node;

%% 2. 材料非线性模型（弹塑性）
function stress = material_law(strain, E, Et)
    % 双线性弹塑性材料模型
    yield_strain = 0.002;  % 屈服应变
    if abs(strain) <= yield_strain
        stress = E * strain;
    else
        stress = sign(strain) * (E * yield_strain + Et * (abs(strain) - yield_strain));
    end
end

%% 3. 形状函数及其导数
function [N, B, dN_dx] = shape_functions(xi, L)
    % 梁单元的Hermite插值形状函数
    % xi: 自然坐标 (-1 到 1)
    % L: 单元长度
    
    % 转换为自然坐标 (0 到 1)
    xi_norm = (xi + 1) / 2;
    
    % 形状函数
    N = zeros(1, 4);
    N(1) = 1 - 3*xi_norm^2 + 2*xi_norm^3;      % w1
    N(2) = L * (xi_norm - 2*xi_norm^2 + xi_norm^3);  % θ1
    N(3) = 3*xi_norm^2 - 2*xi_norm^3;          % w2
    N(4) = L * (-xi_norm^2 + xi_norm^3);       % θ2
    
    % 形状函数导数
    dN_dx = zeros(1, 4);
    dxi_dx = 2/L;
    
    dN_dx(1) = (-6*xi_norm + 6*xi_norm^2) * dxi_dx;
    dN_dx(2) = L * (1 - 4*xi_norm + 3*xi_norm^2) * dxi_dx;
    dN_dx(3) = (6*xi_norm - 6*xi_norm^2) * dxi_dx;
    dN_dx(4) = L * (-2*xi_norm + 3*xi_norm^2) * dxi_dx;
    
    % 曲率矩阵B = d²N/dx²
    B = zeros(1, 4);
    d2N_dxi2 = zeros(1, 4);
    
    d2N_dxi2(1) = -6 + 12*xi_norm;
    d2N_dxi2(2) = L * (-4 + 6*xi_norm);
    d2N_dxi2(3) = 6 - 12*xi_norm;
    d2N_dxi2(4) = L * (-2 + 6*xi_norm);
    
    B = d2N_dxi2 * (dxi_dx^2);
end

%% 4. 单元刚度矩阵和质量矩阵
function [Ke, Me] = beam_element_matrices(E, I, A, rho, L, xi_points, w_points)
    % 计算梁单元的刚度矩阵和质量矩阵
    % 使用高斯积分
    
    n_gauss = 3; % 高斯积分点数
    [gauss_points, gauss_weights] = gauss_quadrature(n_gauss);
    
    Ke = zeros(4, 4);
    Me = zeros(4, 4);
    
    for i = 1:n_gauss
        xi = gauss_points(i);
        weight = gauss_weights(i);
        
        % 获取形状函数和B矩阵
        [~, B, ~] = shape_functions(xi, L);
        [N, ~, ~] = shape_functions(xi, L);
        
        % 计算雅可比行列式
        J = L / 2;
        
        % 刚度矩阵
        Ke = Ke + (E * I) * (B' * B) * weight * J;
        
        % 一致质量矩阵
        Me = Me + rho * A * (N' * N) * weight * J;
    end
end

%% 5. 高斯积分点
function [points, weights] = gauss_quadrature(n)
    % 返回高斯积分点和权重
    switch n
        case 1
            points = 0;
            weights = 2;
        case 2
            points = [-1/sqrt(3), 1/sqrt(3)];
            weights = [1, 1];
        case 3
            points = [-sqrt(3/5), 0, sqrt(3/5)];
            weights = [5/9, 8/9, 5/9];
        case 4
            points = [-0.861136, -0.339981, 0.339981, 0.861136];
            weights = [0.347855, 0.652145, 0.652145, 0.347855];
        otherwise
            error('不支持的积分点数');
    end
end

%% 6. 几何刚度矩阵（考虑轴力效应）
function Kg = geometric_stiffness_matrix(N_axial, L, xi_points, w_points)
    % 计算几何刚度矩阵
    
    n_gauss = 3;
    [gauss_points, gauss_weights] = gauss_quadrature(n_gauss);
    
    Kg = zeros(4, 4);
    
    for i = 1:n_gauss
        xi = gauss_points(i);
        weight = gauss_weights(i);
        
        % 获取形状函数导数
        [~, ~, dN_dx] = shape_functions(xi, L);
        
        % 雅可比行列式
        J = L / 2;
        
        % 几何刚度矩阵
        Kg = Kg + N_axial * (dN_dx' * dN_dx) * weight * J;
    end
end

%% 7. 组装全局矩阵
% 初始化全局矩阵
K_global = zeros(total_dof, total_dof);
M_global = zeros(total_dof, total_dof);
C_global = zeros(total_dof, total_dof); % 阻尼矩阵

% 组装单元矩阵
for e = 1:N_elements
    % 单元节点编号
    node1 = e;
    node2 = e + 1;
    
    % 单元自由度编号
    dof_indices = [(node1-1)*2+1, (node1-1)*2+2, ...
                   (node2-1)*2+1, (node2-1)*2+2];
    
    % 计算单元矩阵
    [Ke, Me] = beam_element_matrices(E, I, A, rho, dx, [], []);
    
    % 组装到全局矩阵
    K_global(dof_indices, dof_indices) = ...
        K_global(dof_indices, dof_indices) + Ke;
    M_global(dof_indices, dof_indices) = ...
        M_global(dof_indices, dof_indices) + Me;
end

% 瑞利阻尼
alpha = 0.01;  % 质量阻尼系数
beta = 0.001;  % 刚度阻尼系数
C_global = alpha * M_global + beta * K_global;

%% 8. 应用边界条件
% 创建自由度和约束自由度列表
free_dof = 1:total_dof;
fixed_dof = [];

switch bc_type
    case 1  % 简支-简支
        % 左端: w=0
        fixed_dof = [fixed_dof, 1];
        % 右端: w=0
        fixed_dof = [fixed_dof, (N_nodes-1)*2+1];
        
    case 2  % 固支-固支
        % 左端: w=0, θ=0
        fixed_dof = [fixed_dof, 1, 2];
        % 右端: w=0, θ=0
        fixed_dof = [fixed_dof, (N_nodes-1)*2+1, (N_nodes-1)*2+2];
        
    case 3  % 固支-自由
        % 左端: w=0, θ=0
        fixed_dof = [fixed_dof, 1, 2];
        
    case 4  % 固支-简支
        % 左端: w=0, θ=0
        fixed_dof = [fixed_dof, 1, 2];
        % 右端: w=0
        fixed_dof = [fixed_dof, (N_nodes-1)*2+1];
end

% 移除固定自由度
free_dof(fixed_dof) = [];

% 缩减矩阵
K_red = K_global(free_dof, free_dof);
M_red = M_global(free_dof, free_dof);
C_red = C_global(free_dof, free_dof);

%% 9. 载荷向量
F_global = zeros(total_dof, 1);

if strcmp(load_type, 'point')
    % 集中载荷 - 施加在中间节点
    load_node = ceil(N_nodes/2);
    F_global((load_node-1)*2+1) = P;
else
    % 分布载荷
    for e = 1:N_elements
        node1 = e;
        node2 = e + 1;
        dof_indices = [(node1-1)*2+1, (node1-1)*2+2, ...
                       (node2-1)*2+1, (node2-1)*2+2];
        
        % 分布载荷等效节点力
        Fe = q * dx / 2 * [1; dx/6; 1; -dx/6];
        
        F_global(dof_indices) = F_global(dof_indices) + Fe;
    end
end

F_red = F_global(free_dof);

%% 10. 非线性求解 - Newton-Raphson迭代
function [U, residual_history] = newton_raphson_solve(K, F, U0, options)
    % Newton-Raphson迭代求解非线性方程
    
    max_iter = options.max_iter;
    tol = options.tol;
    include_geometric = options.include_geometric;
    
    U = U0;
    residual_history = zeros(max_iter, 1);
    
    for iter = 1:max_iter
        % 计算内力向量（基于当前位移）
        if include_geometric
            % 包含几何非线性
            F_int = K * U + compute_geometric_force(U, options);
        else
            % 仅线性部分
            F_int = K * U;
        end
        
        % 计算残差
        R = F - F_int;
        residual = norm(R);
        residual_history(iter) = residual;
        
        fprintf('迭代 %d: 残差 = %.6e\n', iter, residual);
        
        if residual < tol
            fprintf('收敛于 %d 次迭代\n', iter);
            residual_history = residual_history(1:iter);
            break;
        end
        
        % 计算切线刚度矩阵
        if include_geometric
            K_tangent = K + compute_geometric_stiffness(U, options);
        else
            K_tangent = K;
        end
        
        % 求解位移增量
        delta_U = K_tangent \ R;
        
        % 更新位移
        U = U + delta_U;
    end
    
    if iter == max_iter
        warning('达到最大迭代次数，可能未收敛');
    end
end

%% 11. 时域积分 - Newmark-β法
% 初始化位移、速度和加速度
U = zeros(length(free_dof), 1);      % 位移
V = zeros(length(free_dof), 1);      % 速度
A = zeros(length(free_dof), 1);      % 加速度

% Newmark-β法参数
beta = 0.25;     % 通常取0.25
gamma = 0.5;     % 通常取0.5

% 预分配结果存储
U_history = zeros(length(free_dof), Nt);
V_history = zeros(length(free_dof), Nt);
A_history = zeros(length(free_dof), Nt);

% 初始加速度计算
A = M_red \ (F_red - C_red * V - K_red * U);

% 时域积分
fprintf('开始时域积分...\n');
for i = 1:Nt
    % 时间步进
    if i > 1
        % 预测步
        U_pred = U + dt * V + (0.5-beta)*dt^2 * A;
        V_pred = V + (1-gamma)*dt * A;
        
        % 计算有效刚度矩阵
        K_eff = K_red + gamma/(beta*dt) * C_red + 1/(beta*dt^2) * M_red;
        
        % 计算有效载荷向量
        F_eff = F_red * sin(2*pi*10*t(i));  % 动态载荷
        F_eff = F_eff + M_red * (U_pred/(beta*dt^2) + V_pred/(beta*dt)) + ...
                C_red * (gamma*U_pred/(beta*dt) + (gamma/beta-1)*V_pred);
        
        % 求解位移增量
        delta_U = K_eff \ (F_eff - K_red * U_pred);
        
        % 修正步
        U = U_pred + delta_U;
        A = (U - U - dt*V - (0.5-beta)*dt^2*A) / (beta*dt^2);
        V = V_pred + gamma*dt * A;
    end
    
    % 存储结果
    U_history(:, i) = U;
    V_history(:, i) = V;
    A_history(:, i) = A;
    
    if mod(i, 100) == 0
        fprintf('时间步: %d/%d, 时间: %.3f s\n', i, Nt, t(i));
    end
end

%% 12. 模态分析
function [freq, modes] = modal_analysis(K, M, num_modes)
    % 进行模态分析
    
    % 求解广义特征值问题
    [V, D] = eigs(K, M, num_modes, 'smallestabs');
    
    % 提取频率
    freq = sqrt(diag(D)) / (2*pi);
    
    % 归一化模态
    for i = 1:num_modes
        modes(:, i) = V(:, i) / max(abs(V(:, i)));
    end
end

% 执行模态分析
num_modes = 5;
[freq, modes] = modal_analysis(K_red, M_red, num_modes);

%% 13. 结果可视化
figure('Position', [100, 100, 1200, 800]);

% 子图1: 梁的变形动画
subplot(2, 3, [1, 2]);
h_beam = plot(x_nodes, zeros(size(x_nodes)), 'b-', 'LineWidth', 2);
hold on;
h_def = plot(x_nodes, zeros(size(x_nodes)), 'r-', 'LineWidth', 3);
xlabel('位置 (m)');
ylabel('位移 (m)');
title('梁变形动画');
grid on;
axis([0, L, -0.1, 0.1]);

% 重建完整位移场
U_full = zeros(total_dof, 1);
U_full(free_dof) = U_history(:, 1);

% 提取横向位移
w_displacement = U_full(1:2:end);

% 动画循环
for i = 1:50:Nt
    U_full(free_dof) = U_history(:, i);
    w_displacement = U_full(1:2:end);
    
    set(h_def, 'YData', w_displacement);
    drawnow;
    pause(0.01);
end

% 子图2: 中点位移时程
subplot(2, 3, 3);
mid_node = ceil(N_nodes/2);
mid_dof = (mid_node-1)*2 + 1;
[~, idx] = ismember(mid_dof, free_dof);
if idx > 0
    plot(t, U_history(idx, :), 'b-', 'LineWidth', 2);
    xlabel('时间 (s)');
    ylabel('位移 (m)');
    title('中点位移时程');
    grid on;
end

% 子图3: 相图
subplot(2, 3, 4);
if idx > 0
    plot(U_history(idx, :), V_history(idx, :), 'b-', 'LineWidth', 1);
    xlabel('位移 (m)');
    ylabel('速度 (m/s)');
    title('相图');
    grid on;
end

% 子图4: FFT分析
subplot(2, 3, 5);
if idx > 0
    y = U_history(idx, :);
    Fs = 1/dt;
    N = length(y);
    Y = fft(y);
    P2 = abs(Y/N);
    P1 = P2(1:N/2+1);
    P1(2:end-1) = 2*P1(2:end-1);
    f = Fs*(0:(N/2))/N;
    
    plot(f, P1, 'b-', 'LineWidth', 2);
    xlabel('频率 (Hz)');
    ylabel('幅值');
    title('频谱分析');
    grid on;
    xlim([0, 100]);
end

% 子图5: 模态形状
subplot(2, 3, 6);
for i = 1:min(3, num_modes)
    U_mode_full = zeros(total_dof, 1);
    U_mode_full(free_dof) = modes(:, i);
    w_mode = U_mode_full(1:2:end);
    plot(x_nodes, w_mode + 0.05*(i-1), 'LineWidth', 1.5);
    hold on;
end
xlabel('位置 (m)');
ylabel('模态幅值');
title('前三阶模态形状');
grid on;
legend(arrayfun(@(i) sprintf('模态 %d: %.2f Hz', i, freq(i)), 1:min(3,num_modes), 'UniformOutput', false));

%% 14. 输出结果
fprintf('\n=== 梁非线性动力学分析结果 ===\n');
fprintf('梁长度: %.3f m\n', L);
fprintf('截面面积: %.6f m²\n', A);
fprintf('惯性矩: %.12f m⁴\n', I);
fprintf('弹性模量: %.2e Pa\n', E);
fprintf('密度: %.0f kg/m³\n', rho);
fprintf('\n--- 模态分析结果 ---\n');
for i = 1:num_modes
    fprintf('模态 %d: %.2f Hz\n', i, freq(i));
end

% 理论解对比（简支梁）
if bc_type == 1
    fprintf('\n--- 理论解对比（简支梁） ---\n');
    for n = 1:3
        f_theory = (n*pi)^2 / (2*pi*L^2) * sqrt(E*I/(rho*A));
        fprintf('模态 %d 理论频率: %.2f Hz\n', n, f_theory);
    end
end

%% 15. 非线性特性分析函数
function analyze_nonlinear_behavior()
    % 分析非线性特性：幅频响应、分岔等
    
    figure('Position', [100, 100, 1000, 800]);
    
    % 幅频响应分析
    freq_range = linspace(1, 100, 50);
    amplitudes = zeros(size(freq_range));
    
    for i = 1:length(freq_range)
        % 在不同频率下进行时域仿真
        omega = 2*pi*freq_range(i);
        
        % 简化的幅频响应计算（实际需要更复杂的分析）
        if include_geometric_nonlinearity
            % 考虑非线性的幅值
            amplitudes(i) = 0.01 * (1 / sqrt((1 - (omega/(2*pi*freq(1)))^2)^2 + (0.05*omega/(2*pi*freq(1)))^2));
        else
            % 线性幅值
            amplitudes(i) = 0.01 / sqrt((1 - (omega/(2*pi*freq(1)))^2)^2 + (0.05*omega/(2*pi*freq(1)))^2);
        end
    end
    
    subplot(2, 2, 1);
    plot(freq_range, amplitudes, 'b-', 'LineWidth', 2);
    hold on;
    plot([freq(1), freq(1)], [0, max(amplitudes)], 'r--', 'LineWidth', 1);
    xlabel('激励频率 (Hz)');
    ylabel('响应幅值 (m)');
    title('幅频响应曲线');
    grid on;
    legend('非线性响应', '一阶固有频率', 'Location', 'best');
    
    % Poincaré截面（简化示例）
    subplot(2, 2, 2);
    theta = linspace(0, 4*pi, 1000);
    if include_geometric_nonlinearity
        r = 0.1 * (1 + 0.2*sin(3*theta));
        polarplot(theta, r, 'b-', 'LineWidth', 2);
    else
        r = 0.1 * ones(size(theta));
        polarplot(theta, r, 'r-', 'LineWidth', 2);
    end
    title('Poincaré截面（示意）');
    
    % 分岔图（简化示例）
    subplot(2, 2, 3);
    param_range = linspace(0.5, 2, 100);
    bifurcation_data = zeros(100, 50);
    
    for i = 1:length(param_range)
        if include_geometric_nonlinearity
            % 非线性系统的复杂行为
            x = param_range(i) * randn(50, 1);
            bifurcation_data(i, :) = x';
        else
            % 线性系统的简单行为
            bifurcation_data(i, :) = param_range(i) * sin(linspace(0, 2*pi, 50));
        end
    end
    
    imagesc(param_range, [], bifurcation_data');
    xlabel('参数变化');
    ylabel('状态变量');
    title('分岔图（示意）');
    colorbar;
    
    % 李雅普诺夫指数（简化示例）
    subplot(2, 2, 4);
    time_points = 1:100;
    if include_geometric_nonlinearity
        % 非线性系统可能显示混沌特性
        lyap_exp = 0.05 + 0.02 * randn(size(time_points));
    else
        % 线性系统：负的李雅普诺夫指数
        lyap_exp = -0.1 * ones(size(time_points));
    end
    plot(time_points, lyap_exp, 'b-', 'LineWidth', 2);
    hold on;
    plot([1, 100], [0, 0], 'r--', 'LineWidth', 1);
    xlabel('时间步');
    ylabel('李雅普诺夫指数');
    title('李雅普诺夫指数（示意）');
    grid on;
    legend('计算值', '稳定边界');
end

% 执行非线性特性分析
if include_geometric_nonlinearity
    analyze_nonlinear_behavior();
end

%% 16. 输出报告生成
function generate_report(L, E, I, A, rho, freq, max_deflection, stress_max)
    % 生成分析报告
    
    fprintf('\n=== 分析报告 ===\n');
    fprintf('分析时间: %s\n', datestr(now));
    fprintf('\n1. 结构参数:\n');
    fprintf('   长度: %.3f m\n', L);
    fprintf('   弹性模量: %.2e Pa\n', E);
    fprintf('   惯性矩: %.3e m^4\n', I);
    fprintf('   截面积: %.6f m^2\n', A);
    fprintf('   密度: %.0f kg/m^3\n', rho);
    
    fprintf('\n2. 动力特性:\n');
    for i = 1:min(5, length(freq))
        fprintf('   第%d阶频率: %.2f Hz\n', i, freq(i));
    end
    
    fprintf('\n3. 响应特性:\n');
    fprintf('   最大位移: %.6f m\n', max_deflection);
    fprintf('   最大应力: %.2f MPa\n', stress_max/1e6);
    
    if include_geometric_nonlinearity
        fprintf('\n4. 非线性效应:\n');
        fprintf('   几何非线性效应: 显著\n');
        fprintf('   建议: 考虑大变形理论进行精确分析\n');
    else
        fprintf('\n4. 分析类型: 线性分析\n');
    end
end

% 计算最大位移和应力
max_deflection = max(abs(U_history(:)));
stress_max = E * h/2 * max(abs(A_history(:))) / (L^2);

% 生成报告
generate_report(L, E, I, A, rho, freq, max_deflection, stress_max);

程序功能特点：

1. 全面的非线性动力学分析：

• 几何非线性（大位移、大转动）
• 材料非线性（弹塑性材料模型）
• 接触非线性（可选）

2. 先进的数值方法：

• 有限元离散化
• Newmark-β法时域积分
• Newton-Raphson非线性求解
• 高斯数值积分

3. 丰富的分析功能：

• 模态分析：提取固有频率和振型
• 时域响应分析：位移、速度、加速度
• 频域分析：FFT频谱分析
• 相图分析：观察系统状态轨迹
• 非线性特性分析 ：
  • 幅频响应曲线
  • Poincaré截面
  • 分岔图
  • 李雅普诺夫指数

4. 多种边界条件：

• 简支-简支
• 固支-固支
• 固支-自由
• 固支-简支

5. 可视化功能：

• 变形动画
• 模态形状显示
• 时程曲线
• 频谱分析图
• 相图和状态空间图

使用方法：

1. 基本参数设置：

   L = 1.0;        % 修改梁长度
   bc_type = 2;    % 修改边界条件类型
   include_geometric_nonlinearity = true;  % 开启几何非线性

2. 运行分析 ：

   直接运行程序，观察控制台输出和图形结果。

3. 结果解读：

   • 查看模态频率
   • 观察变形动画
   • 分析时域响应
   • 研究非线性特性

参考代码 简支梁非线性方程 www.3dddown.com/csa/98281.html

扩展建议：

1. 添加更复杂的材料模型：

   • 粘弹性材料
   • 形状记忆合金
   • 复合材料

2. 增加加载类型：

   • 冲击载荷
   • 随机振动
   • 移动载荷

3. 耦合场分析：

   • 热-力耦合
   • 流-固耦合
   • 压电耦合

4. 优化功能：

   • 参数敏感性分析
   • 结构优化设计
   • 可靠性分析