廉价喵

[计算流体力学][Matlab] 二维方腔环流情景下流函数涡量的超松弛迭代法计算

1. 代码

% 中山大学 19320053 廉嘉诚

clc;
clf;
clear;

% ---参数初始化---

% 流体密度
rho = 1e3;
% 雷诺数
Re = 3200;
% 动力粘性系数
mu = 1/Re;
% 误差限度
SOR_error_limit = 1e-3;
% 迭代次数限度
FTCS_MaxTimes = 1e5;
SOR_MaxTimes = 1e5;

% 题设顶部移动速度
U_assume = 1;

% ---网格初始化---

% 步长
h = 0.01;
% 时间步长
dt = 0.001;

% 坐标系
x_border = [-0.5 0.5]';
y_border = [0 1]';
x = x_border(1):h:x_border(2);
y = y_border(1):h:y_border(2);
[X,Y] = meshgrid(y,x);

% 矩阵长度
length = size(X,1);

% 场 
Zeta = zeros(size(X));
Psi = zeros(size(X));
P = zeros(size(X));
PG = zeros([length 4]); % 1 左边界 2 右边界 3 下边界 4 上边界
Sp = zeros(size(X));
U = zeros(size(X));
V = zeros(size(X));
U1 = zeros(size(X));
V1 = zeros(size(X));

% 缓存
tmp = zeros(size(X));

% 获得 SOR 迭代法最佳松弛因子
factor = GetOptimalRelaxationFactor(length,length);

% 开始求解
for Zeta_FTCS_times = 1:1:FTCS_MaxTimes
    
    % 流函数 超松弛迭代
        
    % 内点
    
    for Psi_SOR_times = 1:1:SOR_MaxTimes
        
        dPsi_max = 0;
        
        for i = 2:1:length-1
            for j = 2:1:length-1
                
                % 增量
                dPsi = -factor*Psi(i,j)...
                    +factor/4*(...
                    Psi(i,j+1)...
                    +Psi(i,j-1)...
                    +Psi(i+1,j)...
                    +Psi(i-1,j)...
                    +h^2*Zeta(i,j));
                % 取增量绝对值的最大值
                dPsi_max = max([dPsi_max abs(dPsi)]);
                % 基点的新值
                Psi(i,j) = Psi(i,j) + dPsi;
            end
        end
        
        % 直到误差小于一定限度，流函数的迭代方程收敛，才能进入涡量的迭代
        if dPsi_max < SOR_error_limit
            break;
        end
    end
    
    % 涡量 FTCS 格式

    % 边界点(跳过角点)
    
    for i = 2:1:length-1
        
        % 下侧
        Zeta(i,1) = -2.0*Psi(i,2)/(h*h)+2.0*U_assume/h;
        % 上侧
        Zeta(i,length) = -2.0*Psi(i,length-1)/(h*h);
    end
    for j = 2:1:length-1
        
        % 左侧
        Zeta(1,j) = -2.0*Psi(2,j)/(h*h);
        % 右侧
        Zeta(length,j) = -2.0*Psi(length-1,j)/(h*h);
    end
    
    % 内点
    
    Zeta_right = MatrixTranslation(Zeta,1,0);
    Zeta_left = MatrixTranslation(Zeta,-1,0);
    Zeta_up = MatrixTranslation(Zeta,0,1);
    Zeta_down = MatrixTranslation(Zeta,0,-1);
    
    Psi_right = MatrixTranslation(Psi,1,0);
    Psi_left = MatrixTranslation(Psi,-1,0);
    Psi_up = MatrixTranslation(Psi,0,1);
    Psi_down = MatrixTranslation(Psi,0,-1);
    
    U_dZeta_dx = (Psi_up-Psi_down).*(Zeta_right-Zeta_left)/(4*h^2);
    V_dZeta_dy = -(Psi_right-Psi_left).*(Zeta_up-Zeta_down)/(4*h^2);
    mu_Nabla_Zeta = mu*(Zeta_right+Zeta_left+Zeta_up+Zeta_down-4*Zeta)/h^2;
    Zeta_tmp = Zeta + dt*(-U_dZeta_dx-V_dZeta_dy+mu_Nabla_Zeta);
    Zeta(2:length-1,2:length-1) = Zeta_tmp(2:length-1,2:length-1);
end

% 流速
U = (Psi_up-Psi_down)/(2*h);
V = -(Psi_right-Psi_left)/(2*h);
        
% 压强梯度

% 边界点(跳过角点)

for i = 2:1:length-1
    
    % 下侧
    PG(i,3) = rho/h^2*mu*V(i,2);
    % 上侧
    PG(i,4) = rho/h^2*mu*V(i,length-1);;
end
for j = 2:1:length-1
    
    % 左侧
    PG(j,1) = rho/h^2*mu*U(2,j);
    % 右侧
    PG(j,2) = rho/h^2*mu*U(length-1,j);
end
        
% 压强 超松弛迭代

Psi_right_up = MatrixTranslation(Psi,1,1);
Psi_right_down = MatrixTranslation(Psi,1,-1);
Psi_left_up = MatrixTranslation(Psi,-1,1);
Psi_left_down = MatrixTranslation(Psi,-1,-1);

Sp = 2*rho/h^2*(...
    (Psi_right-2*Psi+Psi_left)*(Psi_up-2*Psi+Psi_down) ...
    -(Psi_right_up-Psi_right_down-Psi_left_up+Psi_left_down)/4);

for P_SOR_times = 1:1:SOR_MaxTimes
    
    dP_max = 0;
    
    for i = 1:1:length
        for j = 1:1:length
            
            % 跳过角点
            if i == 1 || i == length
                if j == 1 || j == length
                    continue;
                end
            end
            
            p1 = P(i,j);
            
            % 边界点
            
            % 下侧
            if j == 1
                p1 = P(i,2)-PG(i,3)*h;
                continue;
            % 上侧
            elseif j == length
                p1 = P(i,length-1)+PG(i,4)*h;
                continue;
            end
            
            % 左侧
            if i == 1
                p1 = P(2,j)-PG(j,1)*h;
                continue;
            % 右侧
            elseif i == length
                p1 = P(length-1,j)+PG(j,2)*h;
                continue;
            end
            
            % 内点

            p2 = (...
                P(i,j+1)...
                +P(i,j-1)...
                +P(i+1,j)...
                +P(i-1,j)...
                +h^2*Sp(i,j));
            
            dP = -factor*p1+factor/4*p2;
            
            % 取增量绝对值的最大值
            dP_max = max([dP_max abs(dP)]);
            % 基点的新值
            P(i,j) = P(i,j) + dP;
        end
    end
    
    % 直到误差小于一定限度，流函数的迭代方程收敛，才能进入涡量的迭代
    if dP_max < SOR_error_limit
        break;
    end
end


% 流函数等高线
figure(1);
clf;
contour(Y,X,Psi,Psi(floor(length/2),:));
shading interp;
hold on;
contour(Y,X,Psi,Psi(:,floor(6*length/7)));
hold off;
title('流函数等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;



% 涡量等高线
figure(2);
clf;
hold on;
contour(Y,X,Zeta,Zeta(floor(length/2),:));
hold off;
shading interp;
title('涡量等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;



% 水平速度等高线
figure(3);
clf;
hold on;
contour(Y,X,U,U(:,floor(length/5)));
contour(Y,X,U,U(:,floor(2*length/5)));
contour(Y,X,U,U(:,floor(3*length/5)));
contour(Y,X,U,U(:,floor(4*length/5)));
hold off;
shading interp;
title('水平速度等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;



% 竖直速度等高线
figure(4);
clf;
hold on;
contour(Y,X,V,V(floor(length/5),:));
contour(Y,X,V,V(floor(2*length/5),:));
contour(Y,X,V,V(floor(3*length/5),:));
contour(Y,X,V,V(floor(4*length/5),:));
hold off;
shading interp;
title('竖直速度等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;


% 压强等高线
figure(4);
clf;
hold on;
contour(Y,X,P,P(floor(length/2),:));
contour(Y,X,P,P(floor(length/4),:));
contour(Y,X,P,P(floor(3*length/4),:));
hold off;
shading interp;
title('压强等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;

function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
end

function [A] = MatrixTranslation(A,xstep,ystep)
    % 将矩阵在 x 方向上平移 xstep 个单位，在 y 方向上平移 ystep 个单位
    % 这个平移不是仿射变换，只是元素相对位置的平移
    % 空余的位置用 0 补充
    
    % 移动距离超出矩阵长度的会得到全零
    if abs(xstep) >= size(A,1) || abs(ystep) >= size(A,2)
        A = zeros(size(A));
        return;
    end
    
    A = A;
    
    if xstep > 0
        A = A(:,1:size(A,2)-xstep);
        A = [zeros(size(A,1),xstep) A];
    end
    
    if xstep < 0
        A = A(:,1-xstep:size(A,2));
        A = [A zeros(size(A,1),-xstep)];
    end
    
    if ystep > 0
        A = A(1+ystep:size(A,1),:);
        A = [A;zeros(ystep,size(A,2))];
    end
    
    if ystep < 0
        A = A(1:size(A,1)+ystep,:);
        A = [zeros(-ystep,size(A,2));A];
    end
end

function [A] = DeleteElementForLargerSpace(A,n)
    % 输入一个行向量或者列向量，输出一个全部元素属于输入的列向量
    % 使得输出的列向量各元素之间的间隔变大
    % 共减少 n 个元素
    
    for times = 1:1:n
        
        length = size(A,1)*size(A,2);
        delta = zeros(length-1,1);
        
        for i = 1:1:length-1
            delta(i) = abs(A(i)-A(i+1));
        end
        
        [M,I] = min(delta);
        
        A_tmp = zeros(length-1,1);
        for i = 1:1:I-1
            A_tmp(i) = A(i);
        end
        for i = I+1:1:length
            A_tmp(i-1) = A(i);
        end
        A = A_tmp;
    end
end

2. 报告

3. Debug

3.1 格式

第一版代码

% 中山大学 19320053 廉嘉诚

clc;
clear;

% ---参数初始化---

% 雷诺数
Re = 10;
% 误差限度
error_limit = 1e-6;
% 误差
error = 9999;
% 迭代次数限度
iterationTimes_limit = 100;
% 迭代次数
iterationTimes = 0;

% ---网格初始化---

% 步长
dx = 0.005;
dy = 0.005;

% 边界
x_border = [-0.5 0.5]';
y_border = [0 1]';

% 边界向量
x = x_border(1):dx:x_border(2);
y = y_border(1):dy:y_border(2);

% 求 X 和 Y 矩阵
% X 矩阵每一行都是 X 向量
% Y 矩阵每一列都是 Y 向量
% 和 XOY 坐标系的直觉相配 
[X,Y] = meshgrid(x,y);

% 涡量初始化
Zeta = zeros(size(X));
% 流函数初始化
Psi = zeros(size(X));
% 速度初始化
U = zeros(size(X));
V = zeros(size(X));
for j = 1:1:size(X,2)
    U(1,j) = 1;
end

% 获得 SOR 迭代法最佳松弛因子
factor = GetOptimalRelaxationFactor(size(Zeta,1),size(Zeta,2));
% error > error_limit &&  
% 循环迭代
while iterationTimes < iterationTimes_limit
    % 迭代涡量
    [Zeta,dZeta_max] = Iteration_Vorticity(Zeta,Psi,U,V,factor,dx,1/Re);
    % 迭代流函数
    [Psi,dPsi_max] = Iteration_StreamFunction(Psi,Zeta,factor,dx);
    % 迭代速度
    [U,V,dU_max,dV_max] = Iteration_Velocity(Psi,U,V,dx);
    
    % 取最大误差
    error = max([dZeta_max dPsi_max dU_max dV_max]);
    % 迭代次数加 1
    iterationTimes = iterationTimes + 1;
end

figure();
% 等高线
contour(X,Y,Psi,50);
shading interp;

function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
    
end

function [Zeta_New] = MatrixTranslation(Zeta,xstep,ystep)
    % 将矩阵在 x 方向上平移 xstep 个单位，在 y 方向上平移 ystep 个单位
    % 这个平移不是仿射变换，只是元素相对位置的平移
    % 空余的位置用 0 补充
    
    % 移动距离超出矩阵长度的会得到全零
    if abs(xstep) >= size(Zeta,1) || abs(ystep) >= size(Zeta,2)
        Zeta_New = zeros(size(Zeta));
        return;
    end
    
    Zeta_New = Zeta;
    
    if xstep > 0
        Zeta_New = Zeta_New(:,1:size(Zeta,2)-xstep);
        Zeta_New = [zeros(size(Zeta,1),xstep) Zeta_New];
    end
    
    if xstep < 0
        Zeta_New = Zeta_New(:,1-xstep:size(Zeta,2));
        Zeta_New = [Zeta_New zeros(size(Zeta,1),-xstep)];
    end
    
    if ystep > 0
        Zeta_New = Zeta_New(1:size(Zeta,1)-ystep,:);
        Zeta_New = [zeros(ystep,size(Zeta,2));Zeta_New];
    end
    
    if ystep < 0
        Zeta_New = Zeta_New(1-ystep:size(Zeta,1),:);
        Zeta_New = [Zeta_New;zeros(-ystep,size(Zeta,2))];
    end
end

function [Zeta_new,dZeta_max] = Iteration_Vorticity(Zeta,Psi,U,V,factor,h,mu)
    % 迭代涡量
    
    % Zeta 涡量矩阵
    % Psi 流函数矩阵
    % U,V 速度矩阵
    % factor 超松弛因子
    % h 步长
    % mu 动力粘性系数
    
    % 使用 mesh 函数得到的 X,Y 得到的坐标系为
    % i 行号从小到大代表直角坐标系中纵坐标从小到大
    % j 列号从小到大代表直角坐标系中横坐标从小到大
    
    % 初始化
    Zeta_new = zeros(size(Zeta));
    dZeta_max = 0;
    
    % 迭代 Zeta
    for i = 1:1:size(Zeta,1)
        for j = 1:1:size(Zeta,2)
            
            % 边界条件
            
            % 顶部的水平固壁边界
            if i == 1
                Zeta_new(i,j) = 2*(Psi(i,j)-Psi(i+1,j)+U(i,j)*h)/h^2;
                continue;
            % 底部的水平移动边界
            elseif i == size(Zeta,1)
                Zeta_new(i,j) = 2*(Psi(i-1,j)-Psi(i,j))/h^2;
                continue;
            end
            
            % 左侧的竖直固壁边界
            if j == 1
                Zeta_new(i,j) = 2*(Psi(i,j)-Psi(i,j+1))/h^2;
                continue;
            % 右侧的竖直固壁边界
            elseif j == size(Zeta,2)
                Zeta_new(i,j) = 2*(Psi(i,j-1)-Psi(i,j))/h^2;
                continue;
            end
            
            % 超松弛迭代
            
            % 增量
            dZeta = (1-factor)*Zeta(i,j)+factor*((1-1/mu*h*U(i,j))*Zeta(i,j+1)+Zeta(i,j-1)+(1-1/mu*h*V(i,j))*Zeta(i+1,j)+Zeta(i-1,j))/(4-1/mu*h*(U(i,j)+V(i,j)));
            % 取增量绝对值的最大值
            dZeta_max = max([dZeta_max abs(dZeta)]);
            % 基点的新值
            Zeta_new(i,j) = Zeta(i,j) + dZeta;
        end
    end
end

function [Psi_new,dPsi_max] = Iteration_StreamFunction(Psi,Zeta,factor,h)
    % 迭代流函数
    
    % Psi 流函数矩阵
    % Zeta 涡量矩阵
    % factor 超松弛因子
    % h 步长
    
    % 使用 mesh 函数得到的 X,Y 得到的坐标系为
    % i 行号从小到大代表直角坐标系中纵坐标从小到大
    % j 列号从小到大代表直角坐标系中横坐标从小到大
    
    % 初始化
    Psi_new = zeros(size(Zeta));
    dPsi_max = 0;
    
    % 迭代 Zeta
    for i = 1:1:size(Psi,1)
        for j = 1:1:size(Psi,2)
            
            % 边界条件
            
            % 顶部的水平固壁边界
            if i == 1
                continue;
            % 底部的水平移动边界
            elseif i == size(Zeta,1)
                continue;
            end
            
            % 左侧的竖直固壁边界
            if j == 1
                continue;
            % 右侧的竖直固壁边界
            elseif j == size(Zeta,2)
                continue;
            end
            
            % 超松弛迭代
            
            % 增量
            dPsi = (1-factor)*Psi(i,j)+factor/4*(Psi(i,j+1)+Psi(i,j-1)+Psi(i+1,j)+Psi(i-1,j)+h^2*Zeta(i,j));
            % 取增量绝对值的最大值
            dPsi_max = max([dPsi_max abs(dPsi)]);
            % 基点的新值
            Psi_new(i,j) = Psi(i,j) + dPsi;
        end
    end
end

function [U_new,V_new,dU_max,dV_max] = Iteration_Velocity(Psi,U,V,h)
    % 迭代速度
    
    % Psi 流函数矩阵
    % U,V 速度矩阵
    % h 步长
    
    % 使用 mesh 函数得到的 X,Y 得到的坐标系为
    % i 行号从小到大代表直角坐标系中纵坐标从小到大
    % j 列号从小到大代表直角坐标系中横坐标从小到大
    
    % ψ_(row+1,col) 公式语境下的 ψ_(i,j+1)
    Psi_right = MatrixTranslation(Psi,-1,0);
    % ψ_(row-1,col) 公式语境下的 ψ_(i,j-1)
    Psi_left = MatrixTranslation(Psi,1,0);
    % ψ_(row,col+1) 公式语境下的 ψ_(i+1,j)
    Psi_up = MatrixTranslation(Psi,0,-1);
    % ψ_(row,col-1) 公式语境下的 ψ_(i-1,j)
    Psi_down = MatrixTranslation(Psi,0,1);
    
    % 公式语境下的 u_(i,j+1/2)
    U_right = (Psi_right-Psi)/h;
    % 公式语境下的 u_(i,j-1/2)
    U_left = (Psi-Psi_left)/h;
    % 公式语境下的 v_(i+1/2,j)
    V_down = -(Psi_up-Psi)/h;
    % 公式语境下的 v_(i-1/2,j)
    V_up = -(Psi-Psi_down)/h;
    
    U_tmp = 1/2*(U_left+U_right);
    V_tmp = 1/2*(V_up+V_down);
    
    U_new = U;
    V_new = V;
    
    U_new(2:size(U,1)-1,2:size(U,2)-1) = U_tmp(2:size(U,1)-1,2:size(U,2)-1);
    V_new(2:size(V,1)-1,2:size(V,2)-1) = V_tmp(2:size(V,1)-1,2:size(V,2)-1);
    
    dU_max = max(max(abs(U_new-U)));
    dV_max = max(max(abs(V_new-V)));
end

% function [U_new,V_new,dU_max,dV_max] = Iteration_PressureGradient(Psi,U,V,h)
% 
% end
% function [U_new,V_new,dU_max,dV_max] = Iteration_PoissonEqTerm_Sp(Psi,U,V,h)
% 
% end

做出来是发散的
看了工作区，我觉得应该是 Zeta 的问题，虽然 Zeta 和 Psi 是交替迭代的，但是 Zeta 发散得更快

后面发现我是把增量写错了……因为是增量，所以开头不是 (1-ω) ζ_(i,j)^n 而是 -ω ζ_(i,j)^n

            % 增量
            dZeta = -factor*Zeta(i,j)+factor*((1-1/mu*h*U(i,j))*Zeta(i,j+1)+Zeta(i,j-1)+(1-1/mu*h*V(i,j))*Zeta(i+1,j)+Zeta(i-1,j))/(4-1/mu*h*(U(i,j)+V(i,j)));

            % 增量
            dPsi = factor*Psi(i,j)+factor/4*(Psi(i,j+1)+Psi(i,j-1)+Psi(i+1,j)+Psi(i-1,j)+h^2*Zeta(i,j));

然后又发散了

实在是不知道哪里有问题，看公式，如果公式没错的话，那么 Zeta 不用改，那就是速度有问题了

工作区里面的速度确实很怪

速度的公式是

从工作区看 Psi 也挺正常的，数量级一直很小，为什么会出错呢……

手算了一下，跟工作区还是比较符合的

 u(2,5/2) = (454.59-(-519.44))/0.005 = 194806
 u(2,3/2) = (-519.44-0)/0.005 = -103888
 u(2,2) = (194806+(-103888))/2 = 45459

之后又看到了超松弛的一个错误
我没有在迭代的时候实时更新……

正确的更新是

            % 基点的新值
            Zeta(i,j) = Zeta(i,j) + dZeta;

            % 基点的新值
            Psi(i,j) = Psi(i,j) + dPsi;

改了之后还是发散……
这次我觉得已经不需要看工作区了
或者说看头几次工作区是什么样子的我看不出什么东西

为了方便排错，我把矩阵平移的函数重新写为更和谐的形式

function [A] = MatrixTranslation(A,istep,jstep)
    % 将矩阵在行号增大的方向上平移 istep 个单位，在列号增大的方向上平移 jstep 个单位
    % 这个平移不是仿射变换，只是元素相对位置的平移
    % 空余的位置用 0 补充
    
    % 移动距离超出矩阵长度的会得到全零
    if abs(istep) >= size(A,1) || abs(jstep) >= size(A,2)
        A = zeros(size(A));
        return;
    end
    
    if istep > 0
        A = A(1:size(A,1)-istep,:);
        A = [zeros(istep,size(A,2));A];
    end
    
    if istep < 0
        A = A(1-istep:size(A,1),:);
        A = [A;zeros(-istep,size(A,2))];
    end
    
    if jstep > 0
        A = A(:,1:size(A,2)-jstep);
        A = [zeros(size(A,1),jstep) A];
    end
    
    if jstep < 0
        A = A(:,1-jstep:size(A,2));
        A = [A zeros(size(A,1),-jstep)];
    end
end

之前想的是在 x y 正方向上移动……现在已经看不懂了

一步步走，发现有一步中从 e2 跳到 e50 多，Zeta 的误差是第一个飙上去的

朋友说是有可能公式中分母接近 0 的问题
因此我把一阶导的差分格式中的基点去掉了

但是还是发散……

% 中山大学 19320053 廉嘉诚

clc;
clear;

% ---参数初始化---

% 雷诺数
Re = 10;
% 误差限度
error_limit = 1e-6;
% 误差
error = 9999;
% 迭代次数限度
iterationTimes_limit = 9999;
% 迭代次数
iterationTimes = 0;

% ---网格初始化---

% 步长
dx = 0.01;
dy = 0.01;

% 边界
x_border = [-0.5 0.5]';
y_border = [0 1]';

% 边界向量
x = x_border(1):dx:x_border(2);
y = y_border(1):dy:y_border(2);

% 求 X 和 Y 矩阵
% X 矩阵每一行都是 X 向量
% Y 矩阵每一列都是 Y 向量
% 和 XOY 坐标系的直觉相配 
[X,Y] = meshgrid(x,y);

% 涡量初始化
Zeta = zeros(size(X));
% 流函数初始化
Psi = zeros(size(X));
% 速度初始化
U = zeros(size(X));
V = zeros(size(X));
for j = 1:1:size(X,2)
    U(1,j) = 1;
end

figure();

% 获得 SOR 迭代法最佳松弛因子
factor = GetOptimalRelaxationFactor(size(Zeta,1),size(Zeta,2));

% 循环迭代
while error > error_limit && iterationTimes < iterationTimes_limit
    
    % 迭代涡量
    [Zeta,dZeta_max] = Iteration_Vorticity(Zeta,Psi,U,V,factor,dx,1/Re);
    % 迭代流函数
    [Psi,dPsi_max] = Iteration_StreamFunction(Psi,Zeta,factor,dx);
    % 迭代速度
    [U,V,dU_max,dV_max] = Iteration_Velocity(Psi,U,V,dx);
    
    % 取最大误差
    error = max([dZeta_max dPsi_max dU_max dV_max]);
    % 迭代次数加 1
    iterationTimes = iterationTimes + 1;
    
    % 等高线
    contour(X,Y,Psi,50);
    shading interp;
end


function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
    
end

function [A] = MatrixTranslation(A,istep,jstep)
    % 将矩阵在行号增大的方向上平移 istep 个单位，在列号增大的方向上平移 jstep 个单位
    % 这个平移不是仿射变换，只是元素相对位置的平移
    % 空余的位置用 0 补充
    
    % 移动距离超出矩阵长度的会得到全零
    if abs(istep) >= size(A,1) || abs(jstep) >= size(A,2)
        A = zeros(size(A));
        return;
    end
    
    if istep > 0
        A = A(1:size(A,1)-istep,:);
        A = [zeros(istep,size(A,2));A];
    end
    
    if istep < 0
        A = A(1-istep:size(A,1),:);
        A = [A;zeros(-istep,size(A,2))];
    end
    
    if jstep > 0
        A = A(:,1:size(A,2)-jstep);
        A = [zeros(size(A,1),jstep) A];
    end
    
    if jstep < 0
        A = A(:,1-jstep:size(A,2));
        A = [A zeros(size(A,1),-jstep)];
    end
end

function [Zeta,dZeta_max] = Iteration_Vorticity(Zeta,Psi,U,V,factor,h,mu)
    % 迭代涡量
    
    % Zeta 涡量矩阵
    % Psi 流函数矩阵
    % U,V 速度矩阵
    % factor 超松弛因子
    % h 步长
    % mu 动力粘性系数
    
    % 使用 mesh 函数得到的 X,Y 得到的坐标系为
    % i 行号从小到大代表直角坐标系中纵坐标从小到大
    % j 列号从小到大代表直角坐标系中横坐标从小到大
    
    % 初始化
    dZeta_max = 0;
    
    % 迭代 Zeta
    for i = 1:1:size(Zeta,1)
        for j = 1:1:size(Zeta,2)
            
            % 边界条件
            
            % 顶部的水平固壁边界
            if i == 1
                Zeta(i,j) = 2*(Psi(i,j)-Psi(i+1,j)+U(i,j)*h)/h^2;
                continue;
            % 底部的水平移动边界
            elseif i == size(Zeta,1)
                Zeta(i,j) = 2*(Psi(i-1,j)-Psi(i,j))/h^2;
                continue;
            end
            
            % 左侧的竖直固壁边界
            if j == 1
                Zeta(i,j) = 2*(Psi(i,j)-Psi(i,j+1))/h^2;
                continue;
            % 右侧的竖直固壁边界
            elseif j == size(Zeta,2)
                Zeta(i,j) = 2*(Psi(i,j-1)-Psi(i,j))/h^2;
                continue;
            end
            
            % 超松弛迭代
            
            % 增量
            dZeta = -factor*Zeta(i,j)+factor/4*((1-1/2*1/mu*h*U(i,j))*Zeta(i,j+1)+(1+1/2*1/mu*h*U(i,j))*Zeta(i,j-1)+(1-1/2*1/mu*h*V(i,j))*Zeta(i+1,j)+(1+1/2*1/mu*h*V(i,j))*Zeta(i-1,j));
            % 取增量绝对值的最大值
            dZeta_max = max([dZeta_max abs(dZeta)]);
            % 基点的新值
            Zeta(i,j) = Zeta(i,j) + dZeta;
        end
    end
end

function [Psi,dPsi_max] = Iteration_StreamFunction(Psi,Zeta,factor,h)
    % 迭代流函数
    
    % Psi 流函数矩阵
    % Zeta 涡量矩阵
    % factor 超松弛因子
    % h 步长
    
    % 使用 mesh 函数得到的 X,Y 得到的坐标系为
    % i 行号从小到大代表直角坐标系中纵坐标从小到大
    % j 列号从小到大代表直角坐标系中横坐标从小到大
    
    % 初始化
    dPsi_max = 0;
    
    % 迭代 Zeta
    for i = 1:1:size(Psi,1)
        for j = 1:1:size(Psi,2)
            
            % 边界条件
            
            % 顶部的水平固壁边界
            if i == 1
                continue;
            % 底部的水平移动边界
            elseif i == size(Zeta,1)
                continue;
            end
            
            % 左侧的竖直固壁边界
            if j == 1
                continue;
            % 右侧的竖直固壁边界
            elseif j == size(Zeta,2)
                continue;
            end
            
            % 超松弛迭代
            
            % 增量
            dPsi = -factor*Psi(i,j)+factor/4*(Psi(i,j+1)+Psi(i,j-1)+Psi(i+1,j)+Psi(i-1,j)+h^2*Zeta(i,j));
            % 取增量绝对值的最大值
            dPsi_max = max([dPsi_max abs(dPsi)]);
            % 基点的新值
            Psi(i,j) = Psi(i,j) + dPsi;
        end
    end
end

function [U_new,V_new,dU_max,dV_max] = Iteration_Velocity(Psi,U,V,h)
    % 迭代速度
    
    % Psi 流函数矩阵
    % U,V 速度矩阵
    % h 步长
    
    % 使用 mesh 函数得到的 X,Y 得到的坐标系为
    % i 行号从小到大代表直角坐标系中纵坐标从小到大
    % j 列号从小到大代表直角坐标系中横坐标从小到大
    
    % ψ_(row+1,col) 公式语境下的 ψ_(i,j+1)
    Psi_up = MatrixTranslation(Psi,-1,0);
    % ψ_(row-1,col) 公式语境下的 ψ_(i,j-1)
    Psi_down = MatrixTranslation(Psi,1,0);
    % ψ_(row,col+1) 公式语境下的 ψ_(i+1,j)
    Psi_right = MatrixTranslation(Psi,0,-1);
    % ψ_(row,col-1) 公式语境下的 ψ_(i-1,j)
    Psi_left = MatrixTranslation(Psi,0,1);
    
    % 公式语境下的 u_(i,j+1/2)
    U_up = (Psi_up-Psi)/h;
    % 公式语境下的 u_(i,j-1/2)
    U_down = (Psi-Psi_down)/h;
    % 公式语境下的 v_(i+1/2,j)
    V_right = -(Psi_right-Psi)/h;
    % 公式语境下的 v_(i-1/2,j)
    V_left = -(Psi-Psi_left)/h;
    
    U_tmp = 1/2*(U_down+U_up);
    V_tmp = 1/2*(V_left+V_right);
    
    U_new = U;
    V_new = V;
    
    U_new(2:size(U,1)-1,2:size(U,2)-1) = U_tmp(2:size(U,1)-1,2:size(U,2)-1);
    V_new(2:size(V,1)-1,2:size(V,2)-1) = V_tmp(2:size(V,1)-1,2:size(V,2)-1);
    
    dU_max = max(max(abs(U_new-U)));
    dV_max = max(max(abs(V_new-V)));
end

% function [U_new,V_new,dU_max,dV_max] = Iteration_PressureGradient(Psi,U,V,h)
% 
% end
% function [U_new,V_new,dU_max,dV_max] = Iteration_PoissonEqTerm_Sp(Psi,U,V,h)
% 
% end

迭代前几步，contour(X,Y,Psi,50); 画图得到

到这里已经发散得很厉害了

之后就不用看了

看了很多遍了，实在觉得没有问题
我想想，SOR 涉及到三个变量
我现在的做法是，在 while 中对这三个变量分开迭代，每一个变量迭代的时候其他变量不变
如果我真的什么地方都没有错了的话，那就说明我不能在一个变量迭代的时候保持别人不变

合在一起求的代码

% 中山大学 19320053 廉嘉诚

clc;
clear;

% ---参数初始化---

% 雷诺数
Re = 10;
% 动力粘性系数
mu = 1/Re;
% 误差限度
error_limit = 1e-6;
% 误差
error = 9999;
% 迭代次数限度
iterationTimes_limit = 9999;
% 迭代次数
iterationTimes = 0;

% ---网格初始化---

% 步长
h = 0.01;

% 坐标系
x_border = [-0.5 0.5]';
y_border = [0 1]';
x = x_border(1):h:x_border(2);
y = y_border(1):h:y_border(2);
[X,Y] = meshgrid(x,y);

% 涡量场 
Zeta = zeros(size(X));
Psi = zeros(size(X));
U = zeros(size(X));
V = zeros(size(X));
for j = 1:1:size(X,2)
    U(1,j) = 1;
end

figure();

% 获得 SOR 迭代法最佳松弛因子
factor = GetOptimalRelaxationFactor(size(Zeta,1),size(Zeta,2));

% 直到误差小于误差限度或者迭代次数超过迭代次数限度时才停止迭代
while error > error_limit && iterationTimes < iterationTimes_limit
    
    dZeta_max = 0;
    dPsi_max = 0;
    dU_max = 0;
    dV_max = 0;
    
    % 迭代
    for i = 1:1:size(Zeta,1)
        for j = 1:1:size(Zeta,2)
            
            % 边界条件
            
            % 顶部的水平固壁边界
            if i == 1
                Zeta(i,j) = 2*(Psi(i,j)-Psi(i+1,j)+U(i,j)*h)/h^2;
                continue;
            % 底部的水平移动边界
            elseif i == size(Zeta,1)
                Zeta(i,j) = 2*(Psi(i-1,j)-Psi(i,j))/h^2;
                continue;
            end
            
            % 左侧的竖直固壁边界
            if j == 1
                Zeta(i,j) = 2*(Psi(i,j)-Psi(i,j+1))/h^2;
                continue;
            % 右侧的竖直固壁边界
            elseif j == size(Zeta,2)
                Zeta(i,j) = 2*(Psi(i,j-1)-Psi(i,j))/h^2;
                continue;
            end
            
            % 超松弛迭代
            
            % 增量
            dZeta = -factor*Zeta(i,j)+factor/4*((1-1/2*1/mu*h*U(i,j))*Zeta(i,j+1)+(1+1/2*1/mu*h*U(i,j))*Zeta(i,j-1)+(1-1/2*1/mu*h*V(i,j))*Zeta(i+1,j)+(1+1/2*1/mu*h*V(i,j))*Zeta(i-1,j));
            % 取增量绝对值的最大值
            dZeta_max = max([dZeta_max abs(dZeta)]);
            % 基点的新值
            Zeta(i,j) = Zeta(i,j) + dZeta;
            
            % 增量
            dPsi = -factor*Psi(i,j)+factor/4*(Psi(i,j+1)+Psi(i,j-1)+Psi(i+1,j)+Psi(i-1,j)+h^2*Zeta(i,j));
            % 取增量绝对值的最大值
            dPsi_max = max([dPsi_max abs(dPsi)]);
            % 基点的新值
            Psi(i,j) = Psi(i,j) + dPsi;
            
            u_half_up = (Psi(i+1,j)-Psi(i,j))/h;
            u_half_down = (Psi(i,j)-Psi(i-1,j))/h;
            v_half_right = -(Psi(i,j+1)-Psi(i,j))/h;
            v_half_left = -(Psi(i,j)-Psi(i,j-1))/h;
            
            u_new = 1/2*(u_half_up+u_half_down);
            v_new = 1/2*(v_half_right+v_half_left);
            
            dU = u_new - U(i,j);
            dV = v_new - V(i,j);
            
            dU_max = max([dU_max abs(dU)]);
            dV_max = max([dV_max abs(dU)]);
            
            U(i,j) = u_new;
            V(i,j) = v_new;
        end
    end
    
    % 取最大误差
    error = max([dZeta_max dPsi_max dU_max dV_max]);
    % 迭代次数加 1
    iterationTimes = iterationTimes + 1;
    
end

% 等高线
contour(X,Y,Psi,50);
shading interp;


function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
end

结果还是发散

我看别人对涡量使用 FTCS 是可以的
于是我也写了一个对涡量使用 FTCS 的

% 中山大学 19320053 廉嘉诚

clc;
clear;

% ---参数初始化---

% 雷诺数
Re = 10;
% 动力粘性系数
mu = 1/Re;
% 误差限度
error_limit = 1e-6;
% 误差
error = 9999;
% 迭代次数限度
iterationTimes_limit = 9999;
% 迭代次数
iterationTimes = 0;

% 网格步长
h = 0.01;
% 时间步长
dt = h^2/(4*mu);

% ---网格初始化---

% 坐标系
x_border = [-0.5 0.5]';
y_border = [0 1]';
x = x_border(1):h:x_border(2);
y = y_border(1):h:y_border(2);
[X,Y] = meshgrid(x,y);

% 涡量场 
Zeta = zeros(size(X));
Zeta_old = zeros(size(X));
Psi = zeros(size(X));
U = zeros(size(X));
V = zeros(size(X));
for j = 1:1:size(X,2)
    U(1,j) = 1;
end

figure();

% 获得 SOR 迭代法最佳松弛因子
factor = GetOptimalRelaxationFactor(size(Zeta,1),size(Zeta,2));

% 直到误差小于误差限度或者迭代次数超过迭代次数限度时才停止迭代
while error > error_limit && iterationTimes < iterationTimes_limit
    
    % 迭代
    for i = 1:1:size(X,1)
        for j = 1:1:size(X,2)
            
            % 边界条件
            
            % 速度和流函数的边界值保持不变，所以这里只有涡量的边界值更新
            
            % 顶部的水平固壁边界
            if i == 1
                Zeta(i,j) = 2*(Psi(i,j)-Psi(i+1,j)+U(i,j)*h)/h^2;
                continue;
            % 底部的水平移动边界
            elseif i == size(X,1)
                Zeta(i,j) = 2*(Psi(i-1,j)-Psi(i,j))/h^2;
                continue;
            end
            
            % 左侧的竖直固壁边界
            if j == 1
                Zeta(i,j) = 2*(Psi(i,j)-Psi(i,j+1))/h^2;
                continue;
            % 右侧的竖直固壁边界
            elseif j == size(X,2)
                Zeta(i,j) = 2*(Psi(i,j-1)-Psi(i,j))/h^2;
                continue;
            end
            
            % 流函数 超松弛迭代
            
            dPsi = -factor*Psi(i,j)+factor/4*(Psi(i,j+1)+Psi(i,j-1)+Psi(i+1,j)+Psi(i-1,j)+h^2*Zeta(i,j));
            
            error = max([error abs(dPsi)]);
            
            Psi(i,j) = Psi(i,j) + dPsi;
            
            % 速度
            
            U(i,j) = (Psi(i+1,j)-Psi(i-1,j))/(2*h);
            V(i,j) = -(Psi(i,j+1)-Psi(i,j-1))/(2*h);
            
            % 涡量 FTCS 格式
            U_dZeta_dx = U(i,j)*(Zeta_old(i,j+1)-Zeta_old(i,j-1))/(2*h);
            V_dZeta_dy = V(i,j)*(Zeta_old(i+1,j)-Zeta_old(i-1,j))/(2*h);
            mu_Nabla_Zeta = mu*(Zeta_old(i,j+1)+Zeta_old(i,j-1)+Zeta_old(i+1,j)+Zeta_old(i-1,j)-4*Zeta_old(i,j))/h^2;
            Zeta(i,j) = Zeta_old(i,j)+dt*(-U_dZeta_dx-V_dZeta_dy+mu_Nabla_Zeta);

        end
    end
    
    Zeta_old = Zeta;
    
    % 迭代次数加 1
    iterationTimes = iterationTimes + 1;
end

% 等高线
contour(X,Y,Psi,50);
shading interp;


function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
end

但是还是发散……不懂

对各变量超松弛放在一起的方法加密网格，得到

唉……这个趋势是真的看不出来什么东西

我反复看了别人的计算
别人都没有在迭代公式中计算速度

https://www.zhihu.com/question/52835189
https://curiosityfluids.com/2016/03/14/streamfunction-vorticity-solution-lid-driven-cavity-flow/

虽然我觉得没有差别，但是我还是做了一个

% 中山大学 19320053 廉嘉诚

clc;
clear;

% ---参数初始化---

% 雷诺数
Re = 10;
% 动力粘性系数
mu = 1/Re;
% 误差限度
error_limit = 1e-6;
% 误差
error = 9999;
% 迭代次数限度
iterationTimes_limit = 9999;
% 迭代次数
iterationTimes = 0;

% 顶板速度
U_assume = 1;

% ---网格初始化---

% 步长
h = 0.005;
% 时间步长
dt = h^2/(4*mu);

% 坐标系
x_border = [-0.5 0.5]';
y_border = [0 1]';
x = x_border(1):h:x_border(2);
y = y_border(1):h:y_border(2);
[X,Y] = meshgrid(x,y);

% 涡量场
Zeta = zeros(size(X));
Psi = zeros(size(X));
U = zeros(size(X));
V = zeros(size(X));
for j = 1:1:size(X,2)
    U(1,j) = U_assume;
end

figure();

% 获得 SOR 迭代法最佳松弛因子
factor = GetOptimalRelaxationFactor(size(Zeta,1),size(Zeta,2));

% 直到误差小于误差限度或者迭代次数超过迭代次数限度时才停止迭代
while error > error_limit && iterationTimes < iterationTimes_limit
    
    % 涡量 FTCS 格式
    Zeta_right = MatrixTranslation(Zeta,0,1);
    Zeta_left = MatrixTranslation(Zeta,0,-1);
    Zeta_up = MatrixTranslation(Zeta,1,0);
    Zeta_down = MatrixTranslation(Zeta,-1,0);
    
    Psi_right = MatrixTranslation(Psi,0,1);
    Psi_left = MatrixTranslation(Psi,0,-1);
    Psi_up = MatrixTranslation(Psi,1,0);
    Psi_down = MatrixTranslation(Psi,-1,0);
    
    U_dZeta_dx = (Psi_up-Psi_down).*(Zeta_right-Zeta_left)/(4*h^2);
    V_dZeta_dy = -(Psi_right-Psi_left).*(Zeta_up-Zeta_down)/(4*h^2);
    mu_Nabla_Zeta = mu*(Zeta_right+Zeta_left+Zeta_up+Zeta_down-4*Zeta)/h^2;
    Zeta = Zeta + dt*(-U_dZeta_dx-V_dZeta_dy+mu_Nabla_Zeta);
    
    % 涡量边界条件
    for i = 1:1:size(Zeta,1)
        for j = 1:1:size(Zeta,2)
            
            % 底部的水平移动边界
            if i == 1
                Zeta(i,j) = 2*(Psi(i,j)-Psi(i+1,j)+U_assume*h)/h^2;
                continue;
            % 顶部的水平固壁边界
            elseif i == size(Zeta,1)
                Zeta(i,j) = 2*(Psi(i-1,j)-Psi(i,j))/h^2;
                continue;
            end
            
            % 左侧的竖直固壁边界
            if j == 1
                Zeta(i,j) = 2*(Psi(i,j)-Psi(i,j+1))/h^2;
                continue;
            % 右侧的竖直固壁边界
            elseif j == size(Zeta,2)
                Zeta(i,j) = 2*(Psi(i,j-1)-Psi(i,j))/h^2;
                continue;
            end
        end
    end
    
    % 流函数 普通迭代
    Psi_right = MatrixTranslation(Psi,0,1);
    Psi_left = MatrixTranslation(Psi,0,-1);
    Psi_up = MatrixTranslation(Psi,1,0);
    Psi_down = MatrixTranslation(Psi,-1,0);
    
    Psi_tmp = 1/4*(Psi_right+Psi_left+Psi_up+Psi_down+h^2*Zeta);
    error = max(max(abs(Psi_tmp-Psi)));
    Psi = Psi_tmp;
    
    iterationTimes = iterationTimes + 1;
end

% 等高线
contour(X,Y,Psi,50);
shading interp;



function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
end

function [A] = MatrixTranslation(A,istep,jstep)
    % 将矩阵在行号增大的方向上平移 istep 个单位，在列号增大的方向上平移 jstep 个单位
    % 这个平移不是仿射变换，只是元素相对位置的平移
    % 空余的位置用 0 补充
    
    % 移动距离超出矩阵长度的会得到全零
    if abs(istep) >= size(A,1) || abs(jstep) >= size(A,2)
        A = zeros(size(A));
        return;
    end
    
    if istep > 0
        A = A(1+istep:size(A,1),:);
        A = [A;zeros(istep,size(A,2))];
    end
    
    if istep < 0
        A = A(1:size(A,1)+istep,:);
        A = [zeros(-istep,size(A,2));A];
    end
    
    if jstep > 0
        A = A(:,1+jstep:size(A,2));
        A = [A zeros(size(A,1),jstep)];
    end
    
    if jstep < 0
        A = A(:,1:size(A,2)+jstep);
        A = [zeros(size(A,1),-jstep) A];
    end
end

仍然发散

用回超松弛

% 中山大学 19320053 廉嘉诚

clc;
clear;

% ---参数初始化---

% 雷诺数
Re = 10;
% 动力粘性系数
mu = 1/Re;
% 误差限度
error_limit = 1e-6;
% 误差
error = 9999;
% 迭代次数限度
iterationTimes_limit = 9999;
% 迭代次数
iterationTimes = 0;

% 网格步长
h = 0.01;
% 时间步长
dt = h^2/(4*mu);

% 顶板速度
U_assume = 1;

% ---网格初始化---

% 坐标系
x_border = [-0.5 0.5]';
y_border = [0 1]';
x = x_border(1):h:x_border(2);
y = y_border(1):h:y_border(2);
[X,Y] = meshgrid(x,y);

% 涡量场 
Zeta = zeros(size(X));
Psi = zeros(size(X));
U = zeros(size(X));
V = zeros(size(X));
for j = 1:1:size(X,2)
    U(1,j) = U_assume;
end

figure();

% 获得 SOR 迭代法最佳松弛因子
factor = GetOptimalRelaxationFactor(size(Zeta,1),size(Zeta,2));

% 直到误差小于误差限度或者迭代次数超过迭代次数限度时才停止迭代
while error > error_limit && iterationTimes < iterationTimes_limit
    
    % 涡量 FTCS 格式
    Zeta_right = MatrixTranslation(Zeta,0,1);
    Zeta_left = MatrixTranslation(Zeta,0,-1);
    Zeta_up = MatrixTranslation(Zeta,1,0);
    Zeta_down = MatrixTranslation(Zeta,-1,0);
    
    Psi_right = MatrixTranslation(Psi,0,1);
    Psi_left = MatrixTranslation(Psi,0,-1);
    Psi_up = MatrixTranslation(Psi,1,0);
    Psi_down = MatrixTranslation(Psi,-1,0);
    
    U_dZeta_dx = (Psi_up-Psi_down).*(Zeta_right-Zeta_left)/(4*h^2);
    V_dZeta_dy = -(Psi_right-Psi_left).*(Zeta_up-Zeta_down)/(4*h^2);
    mu_Nabla_Zeta = mu*(Zeta_right+Zeta_left+Zeta_up+Zeta_down-4*Zeta)/h^2;
    Zeta = Zeta + dt*(-U_dZeta_dx-V_dZeta_dy+mu_Nabla_Zeta);
    
    % 迭代
    for i = 1:1:size(X,1)
        for j = 1:1:size(X,2)
            
            % 边界条件
            
            % 速度和流函数的边界值保持不变，所以这里只有涡量的边界值更新
            
            % 顶部的水平固壁边界
            if i == 1
                Zeta(i,j) = 2*(Psi(i,j)-Psi(i+1,j)+U_assume*h)/h^2;
                continue;
            % 底部的水平移动边界
            elseif i == size(X,1)
                Zeta(i,j) = 2*(Psi(i-1,j)-Psi(i,j))/h^2;
                continue;
            end
            
            % 左侧的竖直固壁边界
            if j == 1
                Zeta(i,j) = 2*(Psi(i,j)-Psi(i,j+1))/h^2;
                continue;
            % 右侧的竖直固壁边界
            elseif j == size(X,2)
                Zeta(i,j) = 2*(Psi(i,j-1)-Psi(i,j))/h^2;
                continue;
            end
            
            % 流函数 超松弛迭代
            
            dPsi = -factor*Psi(i,j)+factor/4*(Psi(i,j+1)+Psi(i,j-1)+Psi(i+1,j)+Psi(i-1,j)+h^2*Zeta(i,j));
            
            error = max([error abs(dPsi)]);
            
            Psi(i,j) = Psi(i,j) + dPsi;
        end
    end
    
    % 迭代次数加 1
    iterationTimes = iterationTimes + 1;
    
    % 等高线
    contour(X,Y,Psi,50);
    shading interp;
end

% 等高线
contour(X,Y,Psi,50);
shading interp;



function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
end

function [A] = MatrixTranslation(A,istep,jstep)
    % 将矩阵在行号增大的方向上平移 istep 个单位，在列号增大的方向上平移 jstep 个单位
    % 这个平移不是仿射变换，只是元素相对位置的平移
    % 空余的位置用 0 补充
    
    % 移动距离超出矩阵长度的会得到全零
    if abs(istep) >= size(A,1) || abs(jstep) >= size(A,2)
        A = zeros(size(A));
        return;
    end
    
    if istep > 0
        A = A(1+istep:size(A,1),:);
        A = [A;zeros(istep,size(A,2))];
    end
    
    if istep < 0
        A = A(1:size(A,1)+istep,:);
        A = [zeros(-istep,size(A,2));A];
    end
    
    if jstep > 0
        A = A(:,1+jstep:size(A,2));
        A = [A zeros(size(A,1),jstep)];
    end
    
    if jstep < 0
        A = A(:,1:size(A,2)+jstep);
        A = [zeros(size(A,1),-jstep) A];
    end
end

感觉结果都是一样的

我换了这么多格式，等高线图的趋势还是一样的，那肯定问题出在一个不随格式改变的地方
同时我觉得这个 FTCS 格式还不如我的超松弛快呢

搜到了别人包含可以跑的代码的文章
extension://bfdogplmndidlpjfhoijckpakkdjkkil/pdf/viewer.html?file=http%3A%2F%2Fakshaybatra.yolasite.com%2Fresources%2F2D%2520lid%2520diven%2520cavity%2520final%2520%2520report.pdf

%AuthorAKSHAY BATRA
%MAE 561 Computational Fluid Dynamics

%FINAL PROJECT - LID DRIVEN CAVITY FLOW IN RECATANGULAR CAVITY
%Due on Dec 12 2014.

%-------------------------------------------------------------------------
clear all
close all
clf;

nx=101;ny=101; nt=100000; re=1000; dt=0.001;% Settting the initial parameters
no_it=100000;% number of iterations

Beta=1.5;% relaxation factors
err=0.001;% parameter for SOR iteration

ds=.01;%dx=dy=ds
x=0:ds:1; y=0:ds:1;%dimensions of the cavity

t=0.0;
%-------------------------------------------------------------------------

phi=zeros(nx,ny); omega=zeros(nx,ny); % initializing the variables
u = zeros(nx,ny); v = zeros(nx,ny);

x2d=zeros(nx,ny); y2d=zeros(nx,ny);
b=zeros(nx,ny);p=zeros(nx,ny);pn=zeros(nx,ny);

w=zeros(nx,ny); %p-q/(nx-1),
%-------------------------------------------------------------------------
%Stream Function calculation

for t_step=1:nt % time steps starts
    for iter=1:no_it % streamfunction calculation
    
        w=phi; % by SOR iteration
        for i=2:nx-1;
        
            for j=2:ny-1
                phi(i,j)=0.25*Beta*(phi(i+1,j)+phi(i-1,j)+phi(i,j+1)+phi(i,j-1)+ds*ds*omega(i,j))+(1.0-Beta)*phi(i,j);
            
            end
        end
    
        Err=0.0;
        for i=1:nx
            
            for j=1:ny
                Err=Err+abs(w(i,j)-phi(i,j));
            
            end
        end
        
        if Err <= err,
            break;
        
        end % stop if iteration has converged
    end

    %--------------------------------------------------------------------------
    %boundary conditions for the Vorticity
    
    for i=2:nx-1
        for j=2:ny-1
        
            omega(i,1)=-2.0*phi(i,2)/(ds*ds); % bottom wall
            omega(i,ny)=-2.0*phi(i,ny-1)/(ds*ds)-2.0/ds; % top wall
            
            omega(1,j)=-2.0*phi(2,j)/(ds*ds); % right wall
            omega(nx,j)=-2.0*phi(nx-1,j)/(ds*ds); % left wall
        
        end
    end
    %--------------------------------------------------------------------------
    % RHS Calculation
    for i=2:nx-1;
        for j=2:ny-1 % compute
            w(i,j)=-0.25*((phi(i,j+1)-phi(i,j-1))*(omega(i+1,j)-omega(i-1,j))...
            -(phi(i+1,j)-phi(i-1,j))*(omega(i,j+1)-omega(i,j-1)))/(ds*ds)...
            +(1/re)*(omega(i+1,j)+omega(i-1,j)+omega(i,j+1)+omega(i,j-1)-4.0*omega(i,j))/(ds*ds);
        end
    end
    %--------------------------------------------------------------------------
    % Update the vorticity
    omega(2:nx-1,2:ny-1)=omega(2:nx-1,2:ny-1)+dt*w(2:nx-1,2:ny-1);
    t=t+dt; % increment the time
    for i=1:nx
        for j=1:ny
            x2d(i,j)=x(i);
            y2d(i,j)=y(j);
        end
    end
    %-------------------------------------------------------------------------
    %calculation of U and V
    for i = 2:nx-1
        for j = 2:ny-1
            u(i,j)=(phi(i,j+1)-phi(i,j))/(2*ds);
            v(i,j)=(phi(i+1,j)-phi(i,j))/(2*ds);
            u(:,ny) = 1;
            v(nx,:) =.02;
        end
    end
end
%--------------------------------------------------------------------------
%calculation of pressure
rhs=zeros(nx,ny);
for i=2:nx-1
    for j=2:ny-1
        rhs(i,j)=(((phi(i-1,j)-2*phi(i,j)+phi(i+1,j))/(ds*ds))...
        *((phi(i,j-1)-2*phi(i,j)+phi(i,j+1))/(ds*ds)))...
        - (phi(i+1,j+1)-phi(i+1,j-1)-phi(i-1,j+1)+phi(i-1,j-1))/(4*(ds*ds));
        p(i,j)=(.25*(pn(i+1,j)+pn(i-1,j) + pn(i,j+1)+pn(i,j-1))- 0.5*((rhs(i,j)*ds^2*ds^2)));
    end
    pn=p;
end
%--------------------------------------------------------------------------
% Visualization of the results
figure(1)
contourf(x2d,y2d,omega,[-3:1:-1 -0.5 0.0 0.5 1:1:5 ]),xlabel('nx'),...
ylabel('ny'),title('Vorticity');axis('square','tight');colorbar
title('Vorticity') % plot vorticity
figure(2)
contour(x2d,y2d,phi,[10^-10 10^-7 10^-5 10^-4 0.0100...
0.0300 0.0500 0.0700 0.0900 0.100 0.1100 0.1150 0.1175]),xlabel('nx'),

ylabel('ny'),title('stream function');axis('square','tight');colorbar %streamfunction
figure(3)
contourf(x2d,y2d,u),xlabel('nx'),ylabel('ny'),...

title('U-velocity');axis('square','tight');colorbar
figure(4)
contourf(x2d,y2d,v),xlabel('nx'),ylabel('ny'),...

title('V-velocity');axis('square','tight');colorbar
figure(5)
contourf(x2d,y2d,p,([-2.0:.01:2])),xlabel('nx'),ylabel('ny'),...

title('pressure');
figure(6)

quiver (x2d,y2d,u,v)...,xlabel('nx'),ylabel('ny'),title('VelocityVectour Plot'); axis([0 1 0 1]),axis('square')

%-------------------------------------------------------------------------
%I have been able to get the vorticies in the stream function contour at the corner but

%they are really small(for re 100). I have run the solution to 100,000 iteration at a
%time step of .001. It took 9-10 hours for the solution to compute.Then

%similarlyfor the Re 1000 took even longer but i was able to get the vorticies.

别人的结果是真的漂亮

我发现我跟别人的思路主要不同就在于，别人是在每一个时间步内都要把流函数的迭代格式迭代若干不，一直到流函数收敛，而我是对于每一个时间步，只对流函数迭代一次
这是正确的，因为实际上迭代格式迭代到收敛才代表这个方程解出来了

照着他的写，我写出来就不一样……佛了

正确的是

我写的是

我在右侧比他少了一个负号
噢……我知道了，是我泰勒推错了

即使如此，我改了之后还是写出不出来，会卡在流函数的超松弛迭代那一步

% 中山大学 19320053 廉嘉诚

clc;
clear;

% ---参数初始化---

% 雷诺数
Re = 10;
% 动力粘性系数
mu = 1/Re;
% 误差限度
FTCS_error_limit = 1e-6;
SOR_error_limit = 1e-3;
% 误差
error = 9999;
% 迭代次数限度
iterationTimes_limit = 9999;
% 迭代次数
iterationTimes = 0;

% 题设顶部移动速度
U_assume = 1;

% ---网格初始化---

% 步长
h = 0.01;
% 时间步长
dt = 0.001;
% 涡量最大迭代次数
MaxTimes = 1e5;

% 坐标系
x_border = [-0.5 0.5]';
y_border = [0 1]';
x = x_border(1):h:x_border(2);
y = y_border(1):h:y_border(2);
[X,Y] = meshgrid(x,y);

% 涡量场 
Zeta = zeros(size(X));
Zeta_old = zeros(size(X));
Psi = zeros(size(X));
U = zeros(size(X));
V = zeros(size(X));
for j = 1:1:size(X,2)
    U(1,j) = U_assume;
end

figure();

% 获得 SOR 迭代法最佳松弛因子
% factor = GetOptimalRelaxationFactor(size(Zeta,1),size(Zeta,2));
factor = 1.5;

% 开始求解
for times = 1:1:MaxTimes
    
    while true
        
        % 流函数 超松弛迭代
        
        % 内点
        
        dPsi_max = 0;
        
        for i = 2:1:size(Zeta,1)-1
            for j = 2:1:size(Zeta,2)-1
                
                % 增量
                dPsi = -factor*Psi(i,j)+factor/4*(Psi(i,j+1)+Psi(i,j-1)+Psi(i+1,j)+Psi(i-1,j)+h^2*Zeta(i,j));
                % 取增量绝对值的最大值
                dPsi_max = max([dPsi_max abs(dPsi)]);
                % 基点的新值
                Psi(i,j) = Psi(i,j) + dPsi;
            end
        end
        
        % 直到误差小于一定限度，流函数的迭代方程收敛，才能进入涡量的迭代
        if dPsi_max < SOR_error_limit
            break;
        end
    end
    
    % 涡量 FTCS 格式

    % 边界点(跳过角点)
    
    for j = 2:1:size(Zeta,2)-1
        
        Zeta(1,j) = 2*(-Psi(i+1,j)+U_assume*h)/h^2;
        Zeta(size(Zeta,1),j) = -2*Psi(i-1,j)/h^2;
    end
    for i = 2:1:size(Zeta,1)-1
        
        Zeta(i,1) = -2*Psi(i,j+1)/h^2;
        Zeta(i,size(Zeta,2)) = -2*Psi(i,j-1)/h^2;
    end
    
    % 内点
    
%     Zeta_right = MatrixTranslation(Zeta,0,1);
%     Zeta_left = MatrixTranslation(Zeta,0,-1);
%     Zeta_up = MatrixTranslation(Zeta,1,0);
%     Zeta_down = MatrixTranslation(Zeta,-1,0);
%     
%     Psi_right = MatrixTranslation(Psi,0,1);
%     Psi_left = MatrixTranslation(Psi,0,-1);
%     Psi_up = MatrixTranslation(Psi,1,0);
%     Psi_down = MatrixTranslation(Psi,-1,0);
%     
%     U_dZeta_dx = (Psi_up-Psi_down).*(Zeta_right-Zeta_left)/(4*h^2);
%     V_dZeta_dy = -(Psi_right-Psi_left).*(Zeta_up-Zeta_down)/(4*h^2);
%     mu_Nabla_Zeta = mu*(Zeta_right+Zeta_left+Zeta_up+Zeta_down-4*Zeta)/h^2;
%     Zeta_tmp = Zeta + dt*(-U_dZeta_dx-V_dZeta_dy+mu_Nabla_Zeta);
%     Zeta(2:size(Zeta,1)-1,2:size(Zeta,2)-1) = Zeta_tmp(2:size(Zeta,1)-1,2:size(Zeta,2)-1);
    
    Zeta_old = Zeta;
    
    for i = 2:1:size(Zeta,1)-1
        for j = 2:1:size(Zeta,2)-1
            dZeta = dt*(-(Psi(i+1,j)-Psi(i-1,j))*(Zeta_old(i,j+1)-Zeta_old(i,j-1))/(4*h^2)...
                +(Psi(i,j+1)-Psi(i,j-1))*(Zeta_old(i+1,j)-Zeta_old(i-1,j))/(4*h^2)...
                +mu*(Zeta_old(i,j+1)+Zeta_old(i,j-1)+Zeta_old(i+1,j)+Zeta_old(i-1,j)-4*Zeta_old(i,j))/h^2);
            Zeta_old(i,j) = Zeta(i,j) + dZeta;
        end
    end
    
    Zeta(2:size(Zeta,1)-1,2:size(Zeta,2)-1) = Zeta_old(2:size(Zeta,1)-1,2:size(Zeta,2)-1);
end



% 等高线
contour(X,Y,Psi,50);
shading interp;



function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
end

function [A] = MatrixTranslation(A,istep,jstep)
    % 将矩阵在行号增大的方向上平移 istep 个单位，在列号增大的方向上平移 jstep 个单位
    % 这个平移不是仿射变换，只是元素相对位置的平移
    % 空余的位置用 0 补充
    
    % 移动距离超出矩阵长度的会得到全零
    if abs(istep) >= size(A,1) || abs(jstep) >= size(A,2)
        A = zeros(size(A));
        return;
    end
    
    if istep > 0
        A = A(1+istep:size(A,1),:);
        A = [A;zeros(istep,size(A,2))];
    end
    
    if istep < 0
        A = A(1:size(A,1)+istep,:);
        A = [zeros(-istep,size(A,2));A];
    end
    
    if jstep > 0
        A = A(:,1+jstep:size(A,2));
        A = [A zeros(size(A,1),jstep)];
    end
    
    if jstep < 0
        A = A(:,1:size(A,2)+jstep);
        A = [zeros(size(A,1),-jstep) A];
    end
end

照着答案写的 FTCS 也还是不行

    Zeta_old = Zeta;
    
    for i = 2:1:length-1
        for j = 2:1:size(Zeta,2)-1
            dZeta = -0.25*((Psi(i,j+1)-Psi(i,j-1))*(Zeta(i+1,j)-Zeta(i-1,j))...
            -(Psi(i+1,j)-Psi(i-1,j))*(Zeta(i,j+1)-Zeta(i,j-1)))/(h*h)...
            +mu*(Zeta(i+1,j)+Zeta(i-1,j)+Zeta(i,j+1)+Zeta(i,j-1)-4.0*Zeta(i,j))/(h*h);
            Zeta_old(i,j) = Zeta(i,j) + dt*dZeta;
        end
    end
    
    Zeta = Zeta_old;

再改，我直接全部都复制他的

% 中山大学 19320053 廉嘉诚

clc;
clear;

% ---参数初始化---

% 雷诺数
Re = 10;
% 动力粘性系数
mu = 1/Re;
% 误差限度
SOR_error_limit = 1e-3;
% 迭代次数限度
FTCS_MaxTimes = 1e5;
SOR_MaxTimes = 1e5;

% 题设顶部移动速度
U_assume = 1;

% ---网格初始化---

% 步长
h = 0.01;
% 时间步长
dt = 0.001;

% 坐标系
x_border = [-0.5 0.5]';
y_border = [0 1]';
x = x_border(1):h:x_border(2);
y = y_border(1):h:y_border(2);
[X,Y] = meshgrid(x,y);

% 矩阵长度
length = size(X,1);

% 涡量场 
Zeta = zeros(size(X));
Psi = zeros(size(X));

tmp = zeros(size(X));

figure();

% 获得 SOR 迭代法最佳松弛因子
% factor = GetOptimalRelaxationFactor(length,length);
factor = 1.5;

% 开始求解
for FTCS_times = 1:1:FTCS_MaxTimes
    
    for SOR_times = 1:1:SOR_MaxTimes
        
%         % 流函数 超松弛迭代
%         
%         % 内点
%         
%         dPsi_max = 0;
%         
%         for i = 2:1:length-1
%             for j = 2:1:length-1
%                 
%                 % 增量
%                 dPsi = -factor*Psi(i,j)+factor/4*(Psi(i,j+1)+Psi(i,j-1)+Psi(i+1,j)+Psi(i-1,j)+h^2*Zeta(i,j));
%                 % 取增量绝对值的最大值
%                 dPsi_max = max([dPsi_max abs(dPsi)]);
%                 % 基点的新值
%                 Psi(i,j) = Psi(i,j) + dPsi;
%             end
%         end
%         
%         % 直到误差小于一定限度，流函数的迭代方程收敛，才能进入涡量的迭代
%         if dPsi_max < SOR_error_limit
%             break;
%         end
        
        tmp = Psi; % by SOR iteration
        for i=2:length-1;
        
            for j=2:length-1
                Psi(i,j)=0.25*factor*(Psi(i+1,j)+Psi(i-1,j)+Psi(i,j+1)+Psi(i,j-1)+h*h*Zeta(i,j))+(1.0-factor)*Psi(i,j);
            
            end
        end
    
        Err=0.0;
        for i=1:length
            
            for j=1:length
                Err=Err+abs(tmp(i,j)-Psi(i,j));
            
            end
        end
        
        if Err <= SOR_error_limit
            break;
        
        end % stop if iteration has converged
    end
    
    % 涡量 FTCS 格式

    % 边界点(跳过角点)
    
    for i = 2:1:length-1
        
        Zeta(i,1) = -2.0*Psi(i,2)/(h*h);
        Zeta(i,length) = -2.0*Psi(i,length-1)/(h*h)-2.0*U_assume/h;
    end
    for j = 2:1:length-1
        
        Zeta(1,j) = -2.0*Psi(2,j)/(h*h);
        Zeta(length,j) = -2.0*Psi(length-1,j)/(h*h);
    end
    
    % 内点
    
%     Zeta_right = MatrixTranslation(Zeta,1,0);
%     Zeta_left = MatrixTranslation(Zeta,-1,0);
%     Zeta_up = MatrixTranslation(Zeta,0,1);
%     Zeta_down = MatrixTranslation(Zeta,0,-1);
%     
%     Psi_right = MatrixTranslation(Psi,1,0);
%     Psi_left = MatrixTranslation(Psi,-1,0);
%     Psi_up = MatrixTranslation(Psi,0,1);
%     Psi_down = MatrixTranslation(Psi,0,-1);
%     
%     U_dZeta_dx = (Psi_up-Psi_down).*(Zeta_right-Zeta_left)/(4*h^2);
%     V_dZeta_dy = -(Psi_right-Psi_left).*(Zeta_up-Zeta_down)/(4*h^2);
%     mu_Nabla_Zeta = mu*(Zeta_right+Zeta_left+Zeta_up+Zeta_down-4*Zeta)/h^2;
%     Zeta_tmp = Zeta + dt*(-U_dZeta_dx-V_dZeta_dy+mu_Nabla_Zeta);
%     Zeta(2:length-1,2:length-1) = Zeta_tmp(2:length-1,2:length-1);

    for i=2:length-1;
        for j=2:length-1 % compute
            tmp(i,j) = -0.25*((Psi(i,j+1)-Psi(i,j-1))*(Zeta(i+1,j)-Zeta(i-1,j))...
            -(Psi(i+1,j)-Psi(i-1,j))*(Zeta(i,j+1)-Zeta(i,j-1)))/(h*h)...
            +mu*(Zeta(i+1,j)+Zeta(i-1,j)+Zeta(i,j+1)+Zeta(i,j-1)-4.0*Zeta(i,j))/(h*h);
        end
    end
    Zeta(2:length-1,2:length-1) = Zeta(2:length-1,2:length-1)+dt*tmp(2:length-1,2:length-1);
end



% 等高线
contour(X,Y,Psi,50);
shading interp;



function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
end

function [A] = MatrixTranslation(A,xstep,ystep)
    % 将矩阵在 x 方向上平移 xstep 个单位，在 y 方向上平移 ystep 个单位
    % 这个平移不是仿射变换，只是元素相对位置的平移
    % 空余的位置用 0 补充
    
    % 移动距离超出矩阵长度的会得到全零
    if abs(xstep) >= size(A,1) || abs(ystep) >= size(A,2)
        A = zeros(size(A));
        return;
    end
    
    A = A;
    
    if xstep > 0
        A = A(:,1:size(A,2)-xstep);
        A = [zeros(size(A,1),xstep) A];
    end
    
    if xstep < 0
        A = A(:,1-xstep:size(A,2));
        A = [A zeros(size(A,1),-xstep)];
    end
    
    if ystep > 0
        A = A(1+ystep:size(A,1),:);
        A = [A;zeros(ystep,size(A,2))];
    end
    
    if ystep < 0
        A = A(1:size(A,1)+ystep,:);
        A = [zeros(-ystep,size(A,2));A];
    end
end

还是不行……太怪了
后面试出来是我雷诺数太小了，设了 Re = 1000 就好了

更进一步，都用我自己写的

% 中山大学 19320053 廉嘉诚

clc;
clear;

% ---参数初始化---

% 雷诺数
Re = 1000;
% 动力粘性系数
mu = 1/Re;
% 误差限度
SOR_error_limit = 1e-3;
% 迭代次数限度
FTCS_MaxTimes = 1e5;
SOR_MaxTimes = 1e5;

% 题设顶部移动速度
U_assume = 1;

% ---网格初始化---

% 步长
h = 0.01;
% 时间步长
dt = 0.001;

% 坐标系
x_border = [-0.5 0.5]';
y_border = [0 1]';
x = x_border(1):h:x_border(2);
y = y_border(1):h:y_border(2);
[X,Y] = meshgrid(x,y);

% 矩阵长度
length = size(X,1);

% 涡量场 
Zeta = zeros(size(X));
Psi = zeros(size(X));

tmp = zeros(size(X));

figure();

% 获得 SOR 迭代法最佳松弛因子
% factor = GetOptimalRelaxationFactor(length,length);
factor = 1.5;

% 开始求解
for FTCS_times = 1:1:FTCS_MaxTimes
    
    for SOR_times = 1:1:SOR_MaxTimes
        
        % 流函数 超松弛迭代
        
        % 内点
        
        dPsi_max = 0;
        
        for i = 2:1:length-1
            for j = 2:1:length-1
                
                % 增量
                dPsi = -factor*Psi(i,j)+factor/4*(Psi(i,j+1)+Psi(i,j-1)+Psi(i+1,j)+Psi(i-1,j)+h^2*Zeta(i,j));
                % 取增量绝对值的最大值
                dPsi_max = max([dPsi_max abs(dPsi)]);
                % 基点的新值
                Psi(i,j) = Psi(i,j) + dPsi;
            end
        end
        
        % 直到误差小于一定限度，流函数的迭代方程收敛，才能进入涡量的迭代
        if dPsi_max < SOR_error_limit
            break;
        end
    end
    
    % 涡量 FTCS 格式

    % 边界点(跳过角点)
    
    for i = 2:1:length-1
        
        Zeta(i,1) = -2.0*Psi(i,2)/(h*h);
        Zeta(i,length) = -2.0*Psi(i,length-1)/(h*h)-2.0*U_assume/h;
    end
    for j = 2:1:length-1
        
        Zeta(1,j) = -2.0*Psi(2,j)/(h*h);
        Zeta(length,j) = -2.0*Psi(length-1,j)/(h*h);
    end
    
    % 内点
    
    Zeta_right = MatrixTranslation(Zeta,1,0);
    Zeta_left = MatrixTranslation(Zeta,-1,0);
    Zeta_up = MatrixTranslation(Zeta,0,1);
    Zeta_down = MatrixTranslation(Zeta,0,-1);
    
    Psi_right = MatrixTranslation(Psi,1,0);
    Psi_left = MatrixTranslation(Psi,-1,0);
    Psi_up = MatrixTranslation(Psi,0,1);
    Psi_down = MatrixTranslation(Psi,0,-1);
    
    U_dZeta_dx = (Psi_up-Psi_down).*(Zeta_right-Zeta_left)/(4*h^2);
    V_dZeta_dy = -(Psi_right-Psi_left).*(Zeta_up-Zeta_down)/(4*h^2);
    mu_Nabla_Zeta = mu*(Zeta_right+Zeta_left+Zeta_up+Zeta_down-4*Zeta)/h^2;
    Zeta_tmp = Zeta + dt*(-U_dZeta_dx-V_dZeta_dy+mu_Nabla_Zeta);
    Zeta(2:length-1,2:length-1) = Zeta_tmp(2:length-1,2:length-1);

end



% 等高线
contourf(Y,X,Psi,15);
shading interp;



function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
end

function [A] = MatrixTranslation(A,xstep,ystep)
    % 将矩阵在 x 方向上平移 xstep 个单位，在 y 方向上平移 ystep 个单位
    % 这个平移不是仿射变换，只是元素相对位置的平移
    % 空余的位置用 0 补充
    
    % 移动距离超出矩阵长度的会得到全零
    if abs(xstep) >= size(A,1) || abs(ystep) >= size(A,2)
        A = zeros(size(A));
        return;
    end
    
    A = A;
    
    if xstep > 0
        A = A(:,1:size(A,2)-xstep);
        A = [zeros(size(A,1),xstep) A];
    end
    
    if xstep < 0
        A = A(:,1-xstep:size(A,2));
        A = [A zeros(size(A,1),-xstep)];
    end
    
    if ystep > 0
        A = A(1+ystep:size(A,1),:);
        A = [A;zeros(ystep,size(A,2))];
    end
    
    if ystep < 0
        A = A(1:size(A,1)+ystep,:);
        A = [zeros(-ystep,size(A,2));A];
    end
end

图片输出方式改一下就好了

这个时候输出的 dPsi_max = 8.89e-10

如果我再回来使用两个超松弛，那依然是发散的

% 中山大学 19320053 廉嘉诚

clc;
clear;

% ---参数初始化---

% 雷诺数
Re = 1000;
% 动力粘性系数
mu = 1/Re;
% 误差限度
SOR_error_limit = 1e-3;
% 迭代次数限度
FTCS_MaxTimes = 1e5;
SOR_MaxTimes = 1e5;

% 题设顶部移动速度
U_assume = 1;

% ---网格初始化---

% 步长
h = 0.01;
% 时间步长
dt = 0.001;

% 坐标系
x_border = [-0.5 0.5]';
y_border = [0 1]';
x = x_border(1):h:x_border(2);
y = y_border(1):h:y_border(2);
[X,Y] = meshgrid(x,y);

% 矩阵长度
length = size(X,1);

% 涡量场 
Zeta = zeros(size(X));
Psi = zeros(size(X));

tmp = zeros(size(X));

figure();

% 获得 SOR 迭代法最佳松弛因子
% factor = GetOptimalRelaxationFactor(length,length);
factor = 1.5;

% 开始求解
for FTCS_times = 1:1:FTCS_MaxTimes
    
    for SOR_times = 1:1:SOR_MaxTimes
        
        % 流函数 超松弛迭代
        
        % 内点
        
        dPsi_max = 0;
        
        for i = 2:1:length-1
            for j = 2:1:length-1
                
                % 增量
                dPsi = -factor*Psi(i,j)+factor/4*(Psi(i,j+1)+Psi(i,j-1)+Psi(i+1,j)+Psi(i-1,j)+h^2*Zeta(i,j));
                % 取增量绝对值的最大值
                dPsi_max = max([dPsi_max abs(dPsi)]);
                % 基点的新值
                Psi(i,j) = Psi(i,j) + dPsi;
            end
        end
        
        % 直到误差小于一定限度，流函数的迭代方程收敛，才能进入涡量的迭代
        if dPsi_max < SOR_error_limit
            break;
        end
    end
    
    % 速度
    
    Psi_right = MatrixTranslation(Psi,1,0);
    Psi_left = MatrixTranslation(Psi,-1,0);
    Psi_up = MatrixTranslation(Psi,0,1);
    Psi_down = MatrixTranslation(Psi,0,-1);
    
    U_tmp = (Psi_up-Psi_down)/(2*h);
    V_tmp = -(Psi_right-Psi_left)/(2*h);
    
    U(2:length-1,2:length-1) = U_tmp(2:length-1,2:length-1);
    V(2:length-1,2:length-1) = V_tmp(2:length-1,2:length-1);
    
    % 涡量 超松弛迭代

    % 边界点(跳过角点)
    
    for i = 2:1:length-1
        
        Zeta(i,1) = -2.0*Psi(i,2)/(h*h);
        Zeta(i,length) = -2.0*Psi(i,length-1)/(h*h)-2.0*U_assume/h;
    end
    for j = 2:1:length-1
        
        Zeta(1,j) = -2.0*Psi(2,j)/(h*h);
        Zeta(length,j) = -2.0*Psi(length-1,j)/(h*h);
    end
    
    % 涡量
    
    % 内点
    
    for i = 2:1:length-1
        for j = 2:1:length-1
            
            dZeta = -factor*Zeta(i,j)...
                +factor/4*(...
                (1-1/2*1/mu*h*U(i,j))*Zeta(i+1,j)...
                +(1+1/2*1/mu*h*U(i,j))*Zeta(i-1,j)...
                +(1-1/2*1/mu*h*V(i,j))*Zeta(i,j+1)...
                +(1+1/2*1/mu*h*V(i,j))*Zeta(i,j-1));
            Zeta(i,j) = Zeta(i,j) + dZeta;
        end
    end
end



% 等高线
contourf(Y,X,Psi,15);
shading interp;



function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
end

function [A] = MatrixTranslation(A,xstep,ystep)
    % 将矩阵在 x 方向上平移 xstep 个单位，在 y 方向上平移 ystep 个单位
    % 这个平移不是仿射变换，只是元素相对位置的平移
    % 空余的位置用 0 补充
    
    % 移动距离超出矩阵长度的会得到全零
    if abs(xstep) >= size(A,1) || abs(ystep) >= size(A,2)
        A = zeros(size(A));
        return;
    end
    
    A = A;
    
    if xstep > 0
        A = A(:,1:size(A,2)-xstep);
        A = [zeros(size(A,1),xstep) A];
    end
    
    if xstep < 0
        A = A(:,1-xstep:size(A,2));
        A = [A zeros(size(A,1),-xstep)];
    end
    
    if ystep > 0
        A = A(1+ystep:size(A,1),:);
        A = [A;zeros(ystep,size(A,2))];
    end
    
    if ystep < 0
        A = A(1:size(A,1)+ystep,:);
        A = [zeros(-ystep,size(A,2));A];
    end
end

那就这样吧hhhh起码能算出来了，而且也有我自己做的

之后我灵光一闪，想到，既然一个超松弛要迭代到收敛才能进行下一步，那我是不是可以在一个循环体里面一前一后放两个超松弛，它们都收敛了再进入下一个循环，于是我写了这样的代码
可惜还是发散，那我就没辙了，理论知识不足

% 中山大学 19320053 廉嘉诚

clc;
clf;
clear;

% ---参数初始化---

% 流体密度
rho = 1e3;
% 雷诺数
Re = 3200;
% 动力粘性系数
mu = 1/Re;
% 误差限度
SOR_error_limit = 1e-3;
% 迭代次数限度
MaxTimes = 1e5;
SOR_MaxTimes = 1e5;

% 题设顶部移动速度
U_assume = 1;

% ---网格初始化---

% 步长
h = 0.01;
% 时间步长
dt = 0.001;

% 坐标系
x_border = [-0.5 0.5]';
y_border = [0 1]';
x = x_border(1):h:x_border(2);
y = y_border(1):h:y_border(2);
[X,Y] = meshgrid(y,x);

% 矩阵长度
length = size(X,1);

% 场 
Zeta = zeros(size(X));
Psi = zeros(size(X));
P = zeros(size(X));
PG = zeros([length 4]); % 1 左边界 2 右边界 3 下边界 4 上边界
Sp = zeros(size(X));
U = zeros(size(X));
V = zeros(size(X));
U1 = zeros(size(X));
V1 = zeros(size(X));

% 缓存
tmp = zeros(size(X));

% 获得 SOR 迭代法最佳松弛因子
factor = GetOptimalRelaxationFactor(length,length);

% 开始求解
for times = 1:1:MaxTimes
    
    % 流函数 超松弛迭代

    for Psi_SOR_times = 1:1:SOR_MaxTimes
        
        % 内点
        
        dPsi_max = 0;
        
        for i = 2:1:length-1
            for j = 2:1:length-1
                
                % 增量
                dPsi = -factor*Psi(i,j)...
                    +factor/4*(...
                    Psi(i,j+1)...
                    +Psi(i,j-1)...
                    +Psi(i+1,j)...
                    +Psi(i-1,j)...
                    +h^2*Zeta(i,j));
                % 取增量绝对值的最大值
                dPsi_max = max([dPsi_max abs(dPsi)]);
                % 基点的新值
                Psi(i,j) = Psi(i,j) + dPsi;
            end
        end
        
        % 直到误差小于一定限度，流函数的迭代方程收敛，才能进入涡量的迭代
        if dPsi_max < SOR_error_limit
            break;
        end
    end
    
    % 涡量 超松弛迭代

    % 速度
    
    Psi_right = MatrixTranslation(Psi,1,0);
    Psi_left = MatrixTranslation(Psi,-1,0);
    Psi_up = MatrixTranslation(Psi,0,1);
    Psi_down = MatrixTranslation(Psi,0,-1);
    
    U_tmp = (Psi_up-Psi_down)/(2*h);
    V_tmp = -(Psi_right-Psi_left)/(2*h);
    
    U(2:length-1,2:length-1) = U_tmp(2:length-1,2:length-1);
    V(2:length-1,2:length-1) = V_tmp(2:length-1,2:length-1);
    
    for Zeta_SOR_times = 1:1:SOR_MaxTimes
        
        dZeta_max = 0;
        
        % 边界点(跳过角点)
        
        for i = 2:1:length-1
            
            % 下侧
            dZeta = -2.0*Psi(i,2)/(h*h)+2.0*U_assume/h-Zeta(i,1);
            dZeta_max = max([dZeta_max abs(dZeta)]);
            Zeta(i,1) = Zeta(i,1) + dZeta;
            % 上侧
            dZeta = -2.0*Psi(i,length-1)/(h*h)-Zeta(i,length);
            dZeta_max = max([dZeta_max abs(dZeta)]);
            Zeta(i,length) = Zeta(i,length) + dZeta;
        end
        for j = 2:1:length-1
            
            % 左侧
            dZeta = -2.0*Psi(2,j)/(h*h)-Zeta(1,j);
            dZeta_max = max([dZeta_max abs(dZeta)]);
            Zeta(1,j) = Zeta(1,j) + dZeta;
            % 右侧
            dZeta = -2.0*Psi(length-1,j)/(h*h)-Zeta(length,j);
            dZeta_max = max([dZeta_max abs(dZeta)]);
            Zeta(length,j) = Zeta(length,j) + dZeta;
        end
        
        % 内点
        
        for i = 2:1:length-1
            for j = 2:1:length-1
            
                dZeta = -factor*Zeta(i,j)...
                    +factor/4*(...
                    (1-1/2*1/mu*h*U(i,j))*Zeta(i+1,j)...
                    +(1+1/2*1/mu*h*U(i,j))*Zeta(i-1,j)...
                    +(1-1/2*1/mu*h*V(i,j))*Zeta(i,j+1)...
                    +(1+1/2*1/mu*h*V(i,j))*Zeta(i,j-1));
                dZeta_max = max([dZeta_max abs(dZeta)]);
                Zeta(i,j) = Zeta(i,j) + dZeta;
            end
        end
        
        % 直到误差小于一定限度，流函数的迭代方程收敛，才能进入涡量的迭代
        if dZeta_max < SOR_error_limit
            break;
        end
        
    end
end



% 流速
U = (Psi_up-Psi_down)/(2*h);
V = -(Psi_right-Psi_left)/(2*h);
        
% 压强梯度

% 边界点(跳过角点)

for i = 2:1:length-1
    
    % 下侧
    PG(i,3) = rho/h^2*mu*V(i,2);
    % 上侧
    PG(i,4) = rho/h^2*mu*V(i,length-1);;
end
for j = 2:1:length-1
    
    % 左侧
    PG(j,1) = rho/h^2*mu*U(2,j);
    % 右侧
    PG(j,2) = rho/h^2*mu*U(length-1,j);
end
        
% 压强 超松弛迭代

Psi_right_up = MatrixTranslation(Psi,1,1);
Psi_right_down = MatrixTranslation(Psi,1,-1);
Psi_left_up = MatrixTranslation(Psi,-1,1);
Psi_left_down = MatrixTranslation(Psi,-1,-1);

Sp = 2*rho/h^2*(...
    (Psi_right-2*Psi+Psi_left)*(Psi_up-2*Psi+Psi_down) ...
    -(Psi_right_up-Psi_right_down-Psi_left_up+Psi_left_down)/4);

for P_SOR_times = 1:1:SOR_MaxTimes
    
    dP_max = 0;
    
    for i = 1:1:length
        for j = 1:1:length
            
            % 跳过角点
            if i == 1 || i == length
                if j == 1 || j == length
                    continue;
                end
            end
            
            p1 = P(i,j);
            
            % 边界点
            
            % 下侧
            if j == 1
                p1 = P(i,2)-PG(i,3)*h;
                continue;
            % 上侧
            elseif j == length
                p1 = P(i,length-1)+PG(i,4)*h;
                continue;
            end
            
            % 左侧
            if i == 1
                p1 = P(2,j)-PG(j,1)*h;
                continue;
            % 右侧
            elseif i == length
                p1 = P(length-1,j)+PG(j,2)*h;
                continue;
            end
            
            % 内点

            p2 = (...
                P(i,j+1)...
                +P(i,j-1)...
                +P(i+1,j)...
                +P(i-1,j)...
                +h^2*Sp(i,j));
            
            dP = -factor*p1+factor/4*p2;
            
            % 取增量绝对值的最大值
            dP_max = max([dP_max abs(dP)]);
            % 基点的新值
            P(i,j) = P(i,j) + dP;
        end
    end
    
    % 直到误差小于一定限度，流函数的迭代方程收敛，才能进入涡量的迭代
    if dP_max < SOR_error_limit
        break;
    end
end




% 流函数等高线
figure(1);
clf;
contour(Y,X,Psi,Psi(floor(length/2),:));
shading interp;
hold on;
contour(Y,X,Psi,Psi(:,floor(6*length/7)));
hold off;
title('流函数等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;



% 涡量等高线
figure(2);
clf;
hold on;
contour(Y,X,Zeta,Zeta(floor(length/2),:));
hold off;
shading interp;
title('涡量等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;



% 水平速度等高线
figure(3);
clf;
hold on;
contour(Y,X,U,U(:,floor(length/5)));
contour(Y,X,U,U(:,floor(2*length/5)));
contour(Y,X,U,U(:,floor(3*length/5)));
contour(Y,X,U,U(:,floor(4*length/5)));
hold off;
shading interp;
title('水平速度等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;



% 竖直速度等高线
figure(4);
clf;
hold on;
contour(Y,X,V,V(floor(length/5),:));
contour(Y,X,V,V(floor(2*length/5),:));
contour(Y,X,V,V(floor(3*length/5),:));
contour(Y,X,V,V(floor(4*length/5),:));
hold off;
shading interp;
title('竖直速度等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;


% 压强等高线
figure(4);
clf;
hold on;
contour(Y,X,P,P(floor(length/2),:));
contour(Y,X,P,P(floor(length/4),:));
contour(Y,X,P,P(floor(3*length/4),:));
hold off;
shading interp;
title('压强等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;


function [factor] = GetOptimalRelaxationFactor(m,n)
    % 获得 SOR 法最佳松弛因子
    
    mu = 1/2*(cos(pi/m)+cos(pi/n));
    factor = 2*(1-(1-mu^2)^0.5)/mu^2;
end

function [A] = MatrixTranslation(A,xstep,ystep)
    % 将矩阵在 x 方向上平移 xstep 个单位，在 y 方向上平移 ystep 个单位
    % 这个平移不是仿射变换，只是元素相对位置的平移
    % 空余的位置用 0 补充
    
    % 移动距离超出矩阵长度的会得到全零
    if abs(xstep) >= size(A,1) || abs(ystep) >= size(A,2)
        A = zeros(size(A));
        return;
    end
    
    A = A;
    
    if xstep > 0
        A = A(:,1:size(A,2)-xstep);
        A = [zeros(size(A,1),xstep) A];
    end
    
    if xstep < 0
        A = A(:,1-xstep:size(A,2));
        A = [A zeros(size(A,1),-xstep)];
    end
    
    if ystep > 0
        A = A(1+ystep:size(A,1),:);
        A = [A;zeros(ystep,size(A,2))];
    end
    
    if ystep < 0
        A = A(1:size(A,1)+ystep,:);
        A = [zeros(-ystep,size(A,2));A];
    end
end

function [A] = DeleteElementForLargerSpace(A,n)
    % 输入一个行向量或者列向量，输出一个全部元素属于输入的列向量
    % 使得输出的列向量各元素之间的间隔变大
    % 共减少 n 个元素
    
    for times = 1:1:n
        
        length = size(A,1)*size(A,2);
        delta = zeros(length-1,1);
        
        for i = 1:1:length-1
            delta(i) = abs(A(i)-A(i+1));
        end
        
        [M,I] = min(delta);
        
        A_tmp = zeros(length-1,1);
        for i = 1:1:I-1
            A_tmp(i) = A(i);
        end
        for i = I+1:1:length
            A_tmp(i-1) = A(i);
        end
        A = A_tmp;
    end
end

3.2 画图

这个涡量图是真的难画得好看
如果单纯让 contourf 来选择等高线分布的话，那么等高线条数加到很大也画不出正中心的涡

% 涡量等高线
figure(2);
[M,c] = contourf(Y,X,Zeta,5000);
shading interp;
title('涡量等高线图');
axis('square','tight');
colorbar;

但是如果直接取涡量场的一行作为等高线值的话，又会在一些地方特别密集，也很丑

% 涡量等高线
figure(2);
[M,c] = contourf(Y,X,Zeta,Zeta(floor(length/2),:));
shading interp;
title('涡量等高线图');
axis('square','tight');
colorbar;

tmp1 = Zeta(floor(length/2),1:floor(2*length/5));
tmp2 = Zeta(floor(length/2),floor(2*length/5):floor(3*length/5));
tmp3 = Zeta(floor(length/2),floor(3*length/5):length);

tmp1 = DeleteElementForLargerSpace(tmp1,10);
tmp2 = tmp2';
tmp3 = DeleteElementForLargerSpace(tmp3,10);

tmp = [tmp1;tmp2;tmp3];

% 涡量等高线
figure(2);
[M,c] = contourf(Y,X,Zeta,tmp);
shading interp;
title('涡量等高线图');
axis('square','tight');
colorbar;

function [A] = DeleteElementForLargerSpace(A,n)
    % 输入一个行向量或者列向量，输出一个全部元素属于输入的列向量
    % 使得输出的列向量各元素之间的间隔变大
    % 共减少 n 个元素
    
    for times = 1:1:n
        
        length = size(A,1)*size(A,2);
        delta = zeros(length-1,1);
        
        for i = 1:1:length-1
            delta(i) = abs(A(i)-A(i+1));
        end
        
        [M,I] = min(delta);
        
        A_tmp = zeros(length-1,1);
        for i = 1:1:I-1
            A_tmp(i) = A(i);
        end
        for i = I+1:1:length
            A_tmp(i-1) = A(i);
        end
        A = A_tmp;
    end
end

最后没有办法，只能放弃填充的计划了hhh

然后是流函数图中的小涡的问题

首先我觉得应该是看小涡的数量级，然后人为地按照那个数量级去画
噢，这里我改了边界条件，所以图的方向和上面的图不一样

% 流函数等高线
figure(1);
contour(Y,X,Psi,Psi(floor(length/2),:));
shading interp;
hold on;
contour(Y,X,Psi,[1e-7:1e-7:1e-6]);
contour(Y,X,Psi,[1e-6:1e-6:1e-5]);
contour(Y,X,Psi,[1e-5:1e-5:1e-4]);
contour(Y,X,Psi,[1e-4:1e-4:1e-3]);
hold off;
title('流函数等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;

后来果然发现人为做数量级是不可靠的，真正的等高线值还是要从原矩阵之中取

% 流函数等高线
figure(1);
contour(Y,X,Psi,Psi(floor(length/2),:));
shading interp;
hold on;
contour(Y,X,Psi,Psi(:,floor(6*length/7)));
hold off;
title('流函数等高线图');
xlabel('x');
ylabel('y');
axis('square','tight');
colorbar;

你可能感兴趣的:(Matlab,matlab,CFD,FTCS,SOR,流函数涡量法)

C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
每日一题——第八十四题互联网打工人no1 C语言程序设计每日一练 c语言
题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
《庄子.达生9》钱江潮369
【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
LLM 词汇表落难Coder LLMs NLP 大语言模型大模型 llama 人工智能
Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
运城寻访重逢石头纪实【严建设老照片395 集】我简直能把你想透，当我走进运城的时候。我已急得热汗直流，访问了十九个老头，把晋南的小城转了三周。虽然是悠久的思旧，我仍然是牛样的执... 严建设
运城寻访重逢石头纪实【严建设老照片395集】我简直能把你想透，当我走进运城的时候。我已急得热汗直流，访问了十九个老头，把晋南的小城转了三周。虽然是悠久的思旧，我仍然是牛样的执拗。说什么变换的世情，泛起了过去的逝流，你就是真正的故友。踏破铁鞋的淡愁，已化为不废功夫的范畴，是就像远在天涯近在咫尺，就像是梦乡的邂逅，我紧紧地攥着你的手。你已长成了高高的个头，俊逸的容颜却很清瘦，你那样顽皮的童音，已变到老
少了生活气息我爱大草莓
最近啊，总觉得自己日更的内容缺了点什么。我仔细地想，大概是少了些生活气息。这两三个月减少了许多与别人相处的时间，独自生活，偶尔只是出去买菜，总觉得生活好像变空了许多。买菜的时候会跟档口的阿姨聊一两句话，让自己感觉在真实地生活着。幸好我也不是一宅到底，偶尔周末也会约着跟好朋友见面，面对面交流跟隔着屏幕交流，效果还是不一样的，至少有更为真实的生活感。写作不仅需要有阅读量，有文笔，生活阅历也是非常重要的
数组去重好奇的猫猫猫
整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
Day17笔记-高阶函数 ~在杰难逃~ Python 笔记 python 开发语言 pycharm 数据分析
高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
人生的每一步路都算数 sheli
如果你想打工，一直靠打工赚钱，那你就会不断的希望自己变得更专业，不断的希望能够获得更好的工作机会，升职加薪。如果你的目标志不在此，而是拥有自己的企业，那你的选择就会出现差别。在认真打工的人眼里，会“不务正业”，会总是选择不同岗位，甚至放弃高薪机会。但是这背后都是有更加长远的规划。成功富人所必需的管理技能包括：1．对现金流的管理。2．对系统的管理。3．对人员的管理。所以，在没有获得这些能力之前，只要
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
ARM驱动学习之5 LEDS驱动 JT灬新一嵌入式 C 底层 arm开发学习单片机
ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
Rust基础知识 GRKF15 rust 开发语言后端
1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
《Python数据分析实战终极指南》 xjt921122 python 数据分析开发语言
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
渝婧感恩日记第68天梁渝婧lydia
1.哇！我真是太幸福啦！感恩奇迹感恩训练营毕业典礼，让我能共振到同学们的喜悦和能量，感谢！感谢！感谢！2.哇！我真是太幸福啦！感恩每天早起，运动3公里！这个星期又做到连续三天，不间断！感谢亲爱的渝婧！你真的是非常的棒！加油，继续坚持！感谢！感谢！感谢！3.哇！我真是太幸福啦！感恩曾正波班主任给我们分享的艾宾浩斯的记忆曲线255学习法，让我蠢蠢欲试，感谢！感谢！感谢！4.哇！我真是太幸福啦！感恩胜利
209. 长度最小的子数组（滑动窗口法）清榎 leetcode刷题 c++leetcode 算法
209.长度最小的子数组题目描述：给定一个含有n个正整数的数组和一个正整数target。找出该数组中满足其和≥target的长度最小的连续子数组[numsl,numsl+1,...,numsr-1,numsr]，并返回其长度。如果不存在符合条件的子数组，返回0。解答：法一：直接使用暴力法。两重循环，对每一个元素向后进行寻找，若找到一个子数组≥target，比较其长度和result的大小，如果其长度
STM32中的计时与延时 lupinjia STM32 stm32 单片机
前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
《太虚游》第六十二章。玄牝之威。古楼臭道士
“好好好，流云这孩子深得我心，想必长爻知道是你的话定然会惊喜不已的。”白玄牝听得风流云应了下来，脸色慈和，伸手在他头顶轻轻抚了抚，如同抚在怀中九尾小狐一样自然，极其温柔。身后的四位青丘长老同时一怔，嘴角微动，似要开口劝阻。风流云只感到一道霞光瑞气如有实质一般顺着头顶百会大穴直沉在下丹田内，随后这股气息又逐渐凝聚，似乎给自己吃了什么东西一般。啊喔不好，这祖奶奶该不会是看中我这肉身，像人魔一样，要给她
网络编程基础记得开心一点啊网络
目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
Linux sh命令 fengyehongWorld Linux linux
目录一.基本语法二.选项2.1-c字符串中读取内容，并执行2.1.1基本用法2.1.2获取当前目录下失效的超链接2.2-x每个命令执行之前，将其打印出来2.3结合Here文档使用一.基本语法⏹Linux和Unix系统中用于执行shell脚本或运行命令的命令。sh[选项][脚本文件][参数...]⏹选项-c：从字符串中读取内容，并执行。-x：在每个命令执行之前，将其打印出来。-s：从标准流中读取内容
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
python多线程程序设计之一 IT_Beijing_BIT #Python 程序设计语言 python
python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
新私域是什么平台靠谱吗氧惠佣金真的高
新私域指的是借助与互联网电商，随着平台内商家入驻量、用户量相辅相成的全国化平台。是否靠谱取决于平台是否合规。新私域指的是借助与互联网电商，在传统会员体系外新增的锁定用户跨平台、跨界收益，一种随着平台内商家入驻量、用户量相辅相成的全国化平台。关于新私域平台是否靠谱，这个需要看平台的底层逻辑是否合理、合法、合规以及平台的未来的发展方向氧惠APP抖音购物、看电影、点外卖、打车用氧惠APP！佣金更高、更优
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
web报表工具FineReport常见的数据集报错错误代码和解释老A不折腾 web报表 finereport 代码可视化工具
在使用finereport制作报表，若预览发生错误，很多朋友便手忙脚乱不知所措了，其实没什么，只要看懂报错代码和含义，可以很快的排除错误，这里我就分享一下finereport的数据集报错错误代码和解释，如果有说的不准确的地方，也请各位小伙伴纠正一下。 NS-war-remote=错误代码\:1117 压缩部署不支持远程设计 NS_LayerReport_MultiDs=错误代码
Java的WeakReference与WeakHashMap bylijinnan java 弱引用
首先看看 WeakReference wiki 上 Weak reference 的一个例子： public class ReferenceTest { public static void main(String[] args) throws InterruptedException { WeakReference r = new Wea
Linux——（hostname）主机名与ip的映射 eksliang linux hostname
一、什么是主机名无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。但IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。域名类型 linuxsir.org 这样的；主机名是用于什么的呢？答：在一个局域网中，每台机器都有一个主
oracle 常用技巧 18289753290
oracle常用技巧 ①复制表结构和数据 create table temp_clientloginUser as select distinct userid from tbusrtloginlog ②仅复制数据如果表结构一样 insert into mytable select * &nb
使用c3p0数据库连接池时出现com.mchange.v2.resourcepool.TimeoutException 酷的飞上天空 exception
有一个线上环境使用的是c3p0数据库，为外部提供接口服务。最近访问压力增大后台tomcat的日志里面频繁出现 com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.v2.resourcepool.BasicResou
IT系统分析师如何学习大数据蓝儿唯美大数据
我是一名从事大数据项目的IT系统分析师。在深入这个项目前需要了解些什么呢？学习大数据的最佳方法就是先从了解信息系统是如何工作着手，尤其是数据库和基础设施。同样在开始前还需要了解大数据工具，如Cloudera、Hadoop、Spark、Hive、Pig、Flume、Sqoop与Mesos。系统分析师需要明白如何组织、管理和保护数据。在市面上有几十款数据管理产品可以用于管理数据。你的大数据数据库可能
spring学习——简介 a-john spring
Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只能由EJB完成的事情。然而Spring的用途不仅限于服务器端的开发，从简单性，可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。其主要特征是依赖注入、AOP、持久化、事务、SpringMVC以及Acegi Security 为了降低Java开发的复杂性，
自定义颜色的xml文件 aijuans xml
<?xml version="1.0" encoding="utf-8"?> <resources> <color name="white">#FFFFFF</color> <color name="black">#000000</color> &
运营到底是做什么的？ aoyouzi 运营到底是做什么的？
文章来源：夏叔叔（微信号：woshixiashushu），欢迎大家关注！很久没有动笔写点东西，近些日子，由于爱狗团产品上线，不断面试，经常会被问道一个问题。问：爱狗团的运营主要做什么？答：带着用户一起嗨。为什么是带着用户玩起来呢？究竟什么是运营？运营到底是做什么的？那么，我们先来回答一个更简单的问题——互联网公司对运营考核什么？以爱狗团为例，绝大部分的移动互联网公司，对运营部门的考核分为三块——用
js面向对象类和对象百合不是茶 js 面向对象函数创建类和对象
接触js已经有几个月了,但是对js的面向对象的一些概念根本就是模糊的,js是一种面向对象的语言但又不像java一样有class,js不是严格的面向对象语言 ,js在java web开发的地位和java不相上下 ,其中web的数据的反馈现在主流的使用json,json的语法和js的类和属性的创建相似下面介绍一些js的类和对象的创建的技术一:类和对
web.xml之资源管理对象配置 resource-env-ref bijian1013 java web.xml servlet
resource-env-ref元素来指定对管理对象的servlet引用的声明，该对象与servlet环境中的资源相关联 <resource-env-ref> <resource-env-ref-name>资源名</resource-env-ref-name> <resource-env-ref-type>查找资源时返回的资源类
Create a composite component with a custom namespace sunjing
https://weblogs.java.net/blog/mriem/archive/2013/11/22/jsf-tip-45-create-composite-component-custom-namespace When you developed a composite component the namespace you would be seeing would
【MongoDB学习笔记十二】Mongo副本集服务器角色之Arbiter bit1129 mongodb
一、复本集为什么要加入Arbiter这个角色回答这个问题，要从复本集的存活条件和Aribter服务器的特性两方面来说。什么是Artiber？ An arbiter does not have a copy of data set and cannot become a primary. Replica sets may have arbiters to add a
Javascript开发笔记白糖_ JavaScript
获取iframe内的元素通常我们使用window.frames["frameId"].document.getElementById("divId").innerHTML这样的形式来获取iframe内的元素，这种写法在IE、safari、chrome下都是通过的，唯独在fireforx下不通过。其实jquery的contents方法提供了对if
Web浏览器Chrome打开一段时间后，运行alert无效 bozch Web chorme alert 无效
今天在开发的时候，突然间发现alert在chrome浏览器就没法弹出了，很是怪异。试了试其他浏览器，发现都是没有问题的。开始想以为是chorme浏览器有啥机制导致的，就开始尝试各种代码让alert出来。尝试结果是仍然没有显示出来。这样开发的结果，如果客户在使用的时候没有提示，那会带来致命的体验。哎，没啥办法了就关闭浏览器重启。结果就好了，这也太怪异了。难道是cho
编程之美-高效地安排会议图着色问题贪心算法 bylijinnan 编程之美
import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Random; public class GraphColoringProblem { /**编程之美高效地安排会议图着色问题贪心算法 * 假设要用很多个教室对一组
机器学习相关概念和开发工具 chenbowen00 算法 matlab 机器学习
基本概念：机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。开发工具 M
[宇宙经济学]关于在太空建立永久定居点的可能性 comsci 经济
大家都知道,地球上的房地产都比较昂贵,而且土地证经常会因为新的政府的意志而变幻文本格式........ 所以,在地球议会尚不具有在太空行使法律和权力的力量之前,我们外太阳系统的友好联盟可以考虑在地月系的某些引力平衡点上面,修建规模较大的定居点
oracle 11g database control 证书错误 daizj oracle 证书错误 oracle 11G 安装
oracle 11g database control 证书错误 win7 安装完oracle11后打开 Database control 后，会打开em管理页面，提示证书错误，点“继续浏览此网站”，还是会继续停留在证书错误页面解决办法：是 KB2661254 这个更新补丁引起的，它限制了 RSA 密钥位长度少于 1024 位的证书的使用。具体可以看微软官方公告：
Java I/O之用FilenameFilter实现根据文件扩展名删除文件游其是你 FilenameFilter
在Java中，你可以通过实现FilenameFilter类并重写accept(File dir, String name) 方法实现文件过滤功能。在这个例子中，我们向你展示在“c:\\folder”路径下列出所有“.txt”格式的文件并删除。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
C语言数组的简单以及一维数组的简单排序算法示例，二维数组简单示例 dcj3sjt126com c array
# include <stdio.h> int main(void) { int a[5] = {1, 2, 3, 4, 5}; //a 是数组的名字 5是表示数组元素的个数，并且这五个元素分别用a[0], a[1]...a[4] int i; for (i=0; i<5; ++i) printf("%d\n",
PRIMARY, INDEX, UNIQUE 这3种是一类 PRIMARY 主键。就是唯一且不能为空。 INDEX 索引，普通的 UNIQUE 唯一索引 dcj3sjt126com primary
PRIMARY, INDEX, UNIQUE 这3种是一类PRIMARY 主键。就是唯一且不能为空。INDEX 索引，普通的UNIQUE 唯一索引。不允许有重复。FULLTEXT 是全文索引，用于在一篇文章中，检索文本信息的。举个例子来说，比如你在为某商场做一个会员卡的系统。这个系统有一个会员表有下列字段：会员编号 INT会员姓名
java集合辅助类 Collections、Arrays shuizhaosi888 Collections Arrays HashCode
Arrays、Collections 1 ）数组集合之间转换 public static <T> List<T> asList(T... a) { return new ArrayList<>(a); } a）Arrays.asL
Spring Security（10）——退出登录logout 234390216 logout Spring Security 退出登录 logout-url LogoutFilter
要实现退出登录的功能我们需要在http元素下定义logout元素，这样Spring Security将自动为我们添加用于处理退出登录的过滤器LogoutFilter到FilterChain。当我们指定了http元素的auto-config属性为true时logout定义是会自动配置的，此时我们默认退出登录的URL为“/j_spring_secu
透过源码学前端之 Backbone 三 Model 逐行分析JS源代码 backbone 源码分析 js学习
Backbone 分析第三部分 Model 概述： Model 提供了数据存储，将数据以JSON的形式保存在 Model的 attributes里，但重点功能在于其提供了一套功能强大，使用简单的存、取、删、改数据方法，并在不同的操作里加了相应的监听事件，如每次修改添加里都会触发 change，这在据模型变动来修改视图时很常用，并且与collection建立了关联。
SpringMVC源码总结（七）mvc:annotation-driven中的HttpMessageConverter 乒乓狂魔 springMVC
这一篇文章主要介绍下HttpMessageConverter整个注册过程包含自定义的HttpMessageConverter，然后对一些HttpMessageConverter进行具体介绍。 HttpMessageConverter接口介绍： public interface HttpMessageConverter<T> { /** * Indicate
分布式基础知识和算法理论 bluky999 算法 zookeeper 分布式一致性哈希 paxos
分布式基础知识和算法理论 BY [email protected] 本文永久链接：http://nodex.iteye.com/blog/2103218 在大数据的背景下，不管是做存储，做搜索，做数据分析，或者做产品或服务本身，面向互联网和移动互联网用户，已经不可避免地要面对分布式环境。笔者在此收录一些分布式相关的基础知识和算法理论介绍，在完善自我知识体系的同
Android Studio的.gitignore以及gitignore无效的解决 bell0901 android gitignore
　　github上.gitignore模板合集，里面有各种.gitignore ： https://github.com/github/gitignore 　　自己用的Android Studio下项目的.gitignore文件，对github上的android.gitignore添加了　　　　　　# OSX files　　　　　　//mac os下　　　　　　.DS_Store
成为高级程序员的10个步骤 tomcat_oracle 编程
What 软件工程师的职业生涯要历经以下几个阶段：初级、中级，最后才是高级。这篇文章主要是讲如何通过 10 个步骤助你成为一名高级软件工程师。 Why 得到更多的报酬！因为你的薪水会随着你水平的提高而增加提升你的职业生涯。成为了高级软件工程师之后，就可以朝着架构师、团队负责人、CTO 等职位前进历经更大的挑战。随着你的成长，各种影响力也会提高。
mongdb在linux下的安装 xtuhcy mongodb linux
一、查询linux版本号： lsb_release -a LSB Version: :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noa