simulink比较两个模型接口

clear;
clc;
%%打开新老模型

ModelNew_New='CanMessage_new';
ModelNew_Old='CanMessage_old';

load_system(ModelNew_New);
load_system(ModelNew_Old);

%% S/R接口的输入对比
%Old版本
SRInpath_Old=find_system(ModelNew_Old,'SearchDepth',1,'BlockType','Inport');
SRInName_Old=get_param(SRInpath_Old,'Name');
SRInDataType_Old=get_param(SRInpath_Old,'DataType');
SRInDimensions_Old=get_param(SRInpath_Old,'PortDimensions');
SRInNum_Old=get_param(SRInpath_Old,'Port');
SRInFunctioncall_Old = get_param(SRInpath_Old,'OutputFunctionCall');

Num=2;
SRIn_OLD{1,1}='SRIn_OLDName';
SRIn_OLD{1,2}='DataType';
SRIn_OLD{1,3}='PortDimensions';
SRIn_OLD{1,4}='Port';
SRIn_OLD{1,5}='OutputFunctionCall';
%if length(SRInpath_Old)==1
    %SRIn_OLD{Num,1}=SRInName_Old;
    %SRIn_OLD{Num,2}=SRInDataType_Old;
    %SRIn_OLD{Num,3}=SRInDimensions_Old;
    %SRIn_OLD{Num,4}=SRInNum_Old;
    %SRIn_OLD{Num,5}=SRInFunctioncall_Old;
%else
for i=1:length(SRInpath_Old)
    SRIn_OLD{Num,1}=SRInName_Old{i};
    SRIn_OLD{Num,2}=SRInDataType_Old{i};
    SRIn_OLD{Num,3}=SRInDimensions_Old{i};
    SRIn_OLD{Num,4}=SRInNum_Old{i};
    SRIn_OLD{Num,5}=SRInFunctioncall_Old{i};
    Num=Num+1;
end
%end

%New版本
SRInpath_New=find_system(ModelNew_New,'SearchDepth',1,'BlockType','Inport');
SRInName_New=get_param(SRInpath_New,'Name');
SRInDataType_New=get_param(SRInpath_New,'DataType');
SRInDimensions_New=get_param(SRInpath_New,'PortDimensions');
SRInNum_New=get_param(SRInpath_New,'Port');
SRInFunctioncall_New = get_param(SRInpath_New,'OutputFunctionCall');

Num=2;
SRIn_NEW{1,1}='SRIn_NEWName';
SRIn_NEW{1,2}='DataType';
SRIn_NEW{1,3}='PortDimensions';
SRIn_NEW{1,4}='Port';
SRIn_NEW{1,5}='OutputFunctionCall';
%if length(SRInpath_New)==1
    %SRIn_NEW{Num,1}=SRInName_New;
    %SRIn_NEW{Num,2}=SRInDataType_New;
    %SRIn_NEW{Num,3}=SRInDimensions_New;
    %SRIn_NEW{Num,4}=SRInNum_New;
    %SRIn_NEW{Num,5}=SRInFunctioncall_New;
%else
for i=1:length(SRInpath_New)
    SRIn_NEW{Num,1}=SRInName_New{i};
    SRIn_NEW{Num,2}=SRInDataType_New{i};
    SRIn_NEW{Num,3}=SRInDimensions_New{i};
    SRIn_NEW{Num,4}=SRInNum_New{i};
    SRIn_NEW{Num,5}=SRInFunctioncall_New{i};
    Num=Num+1;
end
%end

%结果排布
SR_InputNum=2;
SR_InputDiff{1,1}='Name';
SR_InputDiff{1,2}='DataType';
SR_InputDiff{1,3}='Dimensions';
SR_InputDiff{1,4}='PortNum';
SR_InputDiff{1,5}='Source';

SRIn_OLDSize=size(SRIn_OLD);
SRIn_NEWSize=size(SRIn_NEW);

%Old模型
for i=1:SRIn_OLDSize(1)
    SR_InputSameFlag=0;
    for j=1:SRIn_NEWSize(1)
        if strcmp(SRIn_OLD{i,1},SRIn_NEW{j,1}) && strcmp(SRIn_OLD{i,2},SRIn_NEW{j,2}) &&...
                strcmp(SRIn_OLD{i,3},SRIn_NEW{j,3})
            SR_InputSameFlag=1;
            break;
        end
    end
    if SR_InputSameFlag==0 && strcmp(SRIn_OLD{i,1},'SRIn_OLDName')==0
        SR_InputDiff{SR_InputNum,1}=SRIn_OLD{i,1};
        SR_InputDiff{SR_InputNum,2}=SRIn_OLD{i,2};
        SR_InputDiff{SR_InputNum,3}=SRIn_OLD{i,3};
        SR_InputDiff{SR_InputNum,4}=SRIn_OLD{i,4};
        SR_InputDiff{SR_InputNum,5}='Old Have';
        SR_InputNum=SR_InputNum+1;
    end
end

%New模型
for i=1:SRIn_NEWSize(1)
    SR_InputSameFlag=0;
    for j=1:SRIn_OLDSize(1)
        if (strcmp(SRIn_OLD{j,1},SRIn_NEW{i,1})&&strcmp(SRIn_OLD{j,2},SRIn_NEW{i,2})&&...
                strcmp(SRIn_OLD{j,3},SRIn_NEW{i,3}))
            SR_InputSameFlag=1;
            break;
        end
    end
    if SR_InputSameFlag==0  && strcmp(SRIn_NEW{i,1},'SRIn_NEWName')==0
        SR_InputDiff{SR_InputNum,1}=SRIn_NEW{i,1};
        SR_InputDiff{SR_InputNum,2}=SRIn_NEW{i,2};
        SR_InputDiff{SR_InputNum,3}=SRIn_NEW{i,3};
        SR_InputDiff{SR_InputNum,4}=SRIn_NEW{i,4};
        SR_InputDiff{SR_InputNum,5}='New Have';
        SR_InputNum=SR_InputNum+1;
    end
end

%% S/R接口的输出对比
%Old版本
SROutpath_Old=find_system(ModelNew_Old,'SearchDepth',1,'BlockType','Outport');
SROutName_Old=get_param(SROutpath_Old,'Name');
SROutDataType_Old=get_param(SROutpath_Old,'DataType');
SROutDimensions_Old=get_param(SROutpath_Old,'PortDimensions');
SROutNum_Old=get_param(SROutpath_Old,'Port');

Num=2;
SROut_OLD{1,1}='SROut_OLDName';
SROut_OLD{1,2}='DataType';
SROut_OLD{1,3}='PortDimensions';
SROut_OLD{1,4}='Port';
%if length(SROutpath_Old)==1
   % SROut_OLD{Num,1}=SROutName_Old;
    %SROut_OLD{Num,2}=SROutDataType_Old;
    %SROut_OLD{Num,3}=SROutDimensions_Old;
   % SROut_OLD{Num,4}=SROutNum_Old;
%else
for i=1:length(SROutpath_Old)
    SROut_OLD{Num,1}=SROutName_Old{i};
    SROut_OLD{Num,2}=SROutDataType_Old{i};
    SROut_OLD{Num,3}=SROutDimensions_Old{i};
    SROut_OLD{Num,4}=SROutNum_Old{i};
    Num=Num+1;
end
%end

%New版本
SROutpath_New=find_system(ModelNew_New,'SearchDepth',1,'BlockType','Outport');
SROutName_New=get_param(SROutpath_New,'Name');
SROutDataType_New=get_param(SROutpath_New,'DataType');
SROutDimensions_New=get_param(SROutpath_New,'PortDimensions');
SROutNum_New=get_param(SROutpath_New,'Port');

Num=2;
SROut_NEW{1,1}='SROut_NEWName';
SROut_NEW{1,2}='DataType';
SROut_NEW{1,3}='PortDimensions';
SROut_NEW{1,4}='Port';
%if length(SROutpath_New)==1
    %SROut_NEW{Num,1}=SROutName_New;
    %SROut_NEW{Num,2}=SROutDataType_New;
    %SROut_NEW{Num,3}=SROutDimensions_New;
    %SROut_NEW{Num,4}=SROutNum_New;
%else
for i=1:length(SROutpath_New)
    SROut_NEW{Num,1}=SROutName_New{i};
    SROut_NEW{Num,2}=SROutDataType_New{i};
    SROut_NEW{Num,3}=SROutDimensions_New{i};
    SROut_NEW{Num,4}=SROutNum_New{i};
    Num=Num+1;
end
%end

%结果排布
SR_OutputNum=2;
SR_OutputDiff{1,1}='Name';
SR_OutputDiff{1,2}='DataType';
SR_OutputDiff{1,3}='Dimensions';
SR_OutputDiff{1,4}='PortNum';
SR_OutputDiff{1,5}='Source';

SROut_OLDSize=size(SROut_OLD);
SROut_NEWSize=size(SROut_NEW);

%Old模型
for i=1:SROut_OLDSize(1)
    SR_OutputSameFlag=0;
    for j=1:SROut_NEWSize(1)
        if (strcmp(SROut_OLD{i,1},SROut_NEW{j,1})&&strcmp(SROut_OLD{i,2},SROut_NEW{j,2})&&...
                strcmp(SROut_OLD{i,3},SROut_NEW{j,3}))
            SR_OutputSameFlag=1;
            break;
        end
    end
    if  SR_OutputSameFlag==0 && strcmp(SROut_OLD{i,1},'SROut_OLDName')==0
        SR_OutputDiff{SR_OutputNum,1}=SROut_OLD{i,1};
        SR_OutputDiff{SR_OutputNum,2}=SROut_OLD{i,2};
        SR_OutputDiff{SR_OutputNum,3}=SROut_OLD{i,3};
        SR_OutputDiff{SR_OutputNum,4}=SROut_OLD{i,4};
        SR_OutputDiff{SR_OutputNum,5}='Old Have';
        SR_OutputNum=SR_OutputNum+1;
    end
end


%New模型
for i=1:SROut_NEWSize(1)
    SR_OutputSameFlag=0;
    for j=1:SROut_OLDSize(1)
        if (strcmp(SROut_OLD{j,1},SROut_NEW{i,1})&&strcmp(SROut_OLD{j,2},SROut_NEW{i,2})&&...
                strcmp(SROut_OLD{j,3},SROut_NEW{i,3}))
            SR_OutputSameFlag=1;
            break;
        end
    end
    if  SR_OutputSameFlag==0 && strcmp(SROut_NEW{i,1},'SROut_NEWName')==0
        SR_OutputDiff{SR_OutputNum,1}=SROut_NEW{i,1};
        SR_OutputDiff{SR_OutputNum,2}=SROut_NEW{i,2};
        SR_OutputDiff{SR_OutputNum,3}=SROut_NEW{i,3};
        SR_OutputDiff{SR_OutputNum,4}=SROut_NEW{i,4};
        SR_OutputDiff{SR_OutputNum,5}='New Have';
        SR_OutputNum=SR_OutputNum+1;
    end
end

%% C/S接口的对比
%旧的CS接口
CSPortPath_Old=find_system(ModelNew_Old,'FindAll','on','BlockType','FunctionCaller');
CSPortName_Old=get_param(CSPortPath_Old,'Name');
CSPortFunPro_Old=get_param(CSPortPath_Old,'FunctionPrototype');
CSPortInput_Old=get_param(CSPortPath_Old,'InputArgumentSpecifications');
CSPortOutput_Old=get_param(CSPortPath_Old,'OutputArgumentSpecifications');

Num=2;
CSPort_OLD{1,1}='CSPort_OLDName';
CSPort_OLD{1,2}='FunctionPrototype';
CSPort_OLD{1,3}='InputArgumentSpecifications';
CSPort_OLD{1,4}='OutputArgumentSpecifications';
if length(CSPortPath_Old)==1
    CSPort_OLD{Num,1}=CSPortName_Old;
    CSPort_OLD{Num,2}=CSPortFunPro_Old;
    CSPort_OLD{Num,3}=CSPortInput_Old;
    CSPort_OLD{Num,4}=CSPortOutput_Old;
else
    for i=1:length(CSPortPath_Old)
        CSPort_OLD{Num,1}=CSPortName_Old{i};
        CSPort_OLD{Num,2}=CSPortFunPro_Old{i};
        CSPort_OLD{Num,3}=CSPortInput_Old{i};
        CSPort_OLD{Num,4}=CSPortOutput_Old{i};
        Num=Num+1;
    end
end


%新的CS接口
CSPortPath_New=find_system(ModelNew_New,'FindAll','on','BlockType','FunctionCaller');
CSPortName_New=get_param(CSPortPath_New,'Name');
CSPortFunPro_New=get_param(CSPortPath_New,'FunctionPrototype');
CSPortInput_New=get_param(CSPortPath_New,'InputArgumentSpecifications');
CSPortOutput_New=get_param(CSPortPath_New,'OutputArgumentSpecifications');

Num=2;
CSPort_NEW{1,1}='CSPort_NEWName';
CSPort_NEW{1,2}='FunctionPrototype';
CSPort_NEW{1,3}='InputArgumentSpecifications';
CSPort_NEW{1,4}='OutputArgumentSpecifications';
if length(CSPortPath_New)==1
    CSPort_NEW{Num,1}=CSPortName_New;
    CSPort_NEW{Num,2}=CSPortFunPro_New;
    CSPort_NEW{Num,3}=CSPortInput_New;
    CSPort_NEW{Num,4}=CSPortOutput_New;
else
    for i=1:length(CSPortPath_New)
        CSPort_NEW{Num,1}=CSPortName_New{i};
        CSPort_NEW{Num,2}=CSPortFunPro_New{i};
        CSPort_NEW{Num,3}=CSPortInput_New{i};
        CSPort_NEW{Num,4}=CSPortOutput_New{i};
        Num=Num+1;
    end
end


%结果排布
CSPortNum=2;
CSPortDiff{1,1}='Name';
CSPortDiff{1,2}='FunctionPrototype';
CSPortDiff{1,3}='InputArgumentSpecifications';
CSPortDiff{1,4}='OutputArgumentSpecifications';
CSPortDiff{1,5}='Source';

CSPort_OLDSize=size(CSPort_OLD);
CSPort_NEWSize=size(CSPort_NEW);

%Old模型
for i=1:CSPort_OLDSize(1)
    CSPortSameFlag=0;
    for j=1:CSPort_NEWSize(1)
        if (strcmp(CSPort_OLD{i,1},CSPort_NEW{j,1})&& strcmp(CSPort_OLD{i,2},CSPort_NEW{j,2})&&...
                strcmp(CSPort_OLD{i,3},CSPort_NEW{j,3})&&strcmp(CSPort_OLD{i,4},CSPort_NEW{j,4}))
            CSPortSameFlag=1;
            break;
        end
    end
    if  CSPortSameFlag==0 && strcmp(CSPort_OLD{i,1},'CSPort_OLDName')==0
        CSPortDiff{CSPortNum,1}=CSPort_OLD{i,1};
        CSPortDiff{CSPortNum,2}=CSPort_OLD{i,2};
        CSPortDiff{CSPortNum,3}=CSPort_OLD{i,3};
        CSPortDiff{CSPortNum,4}=CSPort_OLD{i,4};
        CSPortDiff{CSPortNum,5}='Old Have';
        CSPortNum=CSPortNum+1;
    end
end
    

%New模型
for i=1:CSPort_NEWSize(1)
    CSPortSameFlag=0;
    for j=1:CSPort_OLDSize(1)
        if (strcmp(CSPort_OLD{j,1},CSPort_NEW{i,1})&& strcmp(CSPort_OLD{j,2},CSPort_NEW{i,2})&&...
                strcmp(CSPort_OLD{j,3},CSPort_NEW{i,3})&&strcmp(CSPort_OLD{j,4},CSPort_NEW{i,4}))
            CSPortSameFlag=1;
            break;
        end
    end
    if  CSPortSameFlag==0 && strcmp(CSPort_NEW{i,1},'CSPort_NEWName')==0
        CSPortDiff{CSPortNum,1}=CSPort_NEW{i,1};
        CSPortDiff{CSPortNum,2}=CSPort_NEW{i,2};
        CSPortDiff{CSPortNum,3}=CSPort_NEW{i,3};
        CSPortDiff{CSPortNum,4}=CSPort_NEW{i,4};
        CSPortDiff{CSPortNum,5}='New Have';
        CSPortNum=CSPortNum+1;
    end
end

%% 调度系统对比
%Old版本
SystemPath_Old=find_system(ModelNew_Old,'SearchDepth',1,'BlockType','SubSystem');
SystemName_Old=get_param(SystemPath_Old,'Name');

Num=2;
System_OLD{1,1}='System_OLDName';
%if length(SystemPath_Old)==1
    %System_OLD{Num,1}=SystemName_Old;
%else
for i=1:length(SystemPath_Old)
    System_OLD{Num,1}=SystemName_Old{i};
    Num=Num+1;
end
%end

%New版本
SystemPath_New=find_system(ModelNew_New,'SearchDepth',1,'BlockType','SubSystem');
SystemName_New=get_param(SystemPath_New,'Name');

Num=2;
System_NEW{1,1}='System_NEWName';
%if length(SystemPath_New)==1
    %System_NEW{Num,1}=SystemName_New;
%else
    for i=1:length(SystemPath_New)
        System_NEW{Num,1}=SystemName_New{i};
        Num=Num+1;
    end
%end


%结果排布
SystemNum=2;
SystemDiff{1,1}='Name';
SystemDiff{1,2}='Source';

System_OLDSize=size(System_OLD);
System_NEWSize=size(System_NEW);

%Old模型
for i=1:System_OLDSize(1)
    SystemSameFlag=0;
    for j=1:System_NEWSize(1)
        if strcmp(System_OLD{i,1},System_NEW{j,1})
            SystemSameFlag=1;
            break;
        end
    end
    if  SystemSameFlag==0 && strcmp(System_OLD{i,1},'System_OLDName')==0
        SystemDiff{SystemNum,1}=System_OLD{i,1};
        SystemDiff{SystemNum,2}='Old Have';
        SystemNum=SystemNum+1;
    end
end

%New模型
for i=1:System_NEWSize(1)
    SystemSameFlag=0;
    for j=1:System_OLDSize(1)
        if strcmp(System_NEW{i,1},System_OLD{j,1})
            SystemSameFlag=1;
            break;
        end
    end
    if  SystemSameFlag==0 && strcmp(System_NEW{i,1},'System_NEWName')==0
        SystemDiff{SystemNum,1}=System_NEW{i,1};
        SystemDiff{SystemNum,2}='New Have';
        SystemNum=SystemNum+1;
    end
end

%% 结果Summary
CheckSummary{1,1}='Name';
CheckSummary{1,2}='PortType';
CheckSummary{1,3}='差异结果';
CheckNum=2;


%SR输入接口，对比差异
InputSize=size(SR_InputDiff);
if  InputSize(1)>1
    for i=2:InputSize(1)
        CheckSummaryFlag=0;
        for j=2:InputSize(1)
            if   strcmp(SR_InputDiff{i,5},'Old Have')
                if  strcmp(SR_InputDiff{i,1},SR_InputDiff{j,1}) && strcmp(SR_InputDiff{j,5},'New Have')
                    CheckSummary{CheckNum,1}=SR_InputDiff{i,1};
                    CheckSummary{CheckNum,2}='S/R输入接口';
                    if   strcmp(SR_InputDiff{i,2},SR_InputDiff{j,2})==0
                          CheckSummary{CheckNum,3}='Deviation---数据类型';
                    else
                          CheckSummary{CheckNum,3}='Deviation---维度';
                    end
                    CheckNum=CheckNum+1;
                    CheckSummaryFlag=1;
                    break;
                end
            elseif  strcmp(SR_InputDiff{i,5},'New Have')
                if  strcmp(SR_InputDiff{i,1},SR_InputDiff{j,1}) && i~=j
                    CheckSummaryFlag=1;
                    break;
                end
            end
        end
        if  CheckSummaryFlag==0
            CheckSummary{CheckNum,1}=SR_InputDiff{i,1};
            CheckSummary{CheckNum,2}='S/R输入接口';
            CheckSummary{CheckNum,3}=SR_InputDiff{i,5};
            CheckNum=CheckNum+1;
        end
    end
end



%SR输出接口，对比差异
OutputSize=size(SR_OutputDiff);
if  OutputSize(1)>1
    for i=2:OutputSize(1)
        CheckSummaryFlag=0;
        for j=2:OutputSize(1)
            if   strcmp(SR_OutputDiff{i,5},'Old Have')
                if  strcmp(SR_OutputDiff{i,1},SR_OutputDiff{j,1}) && strcmp(SR_OutputDiff{j,5},'New Have')
                    CheckSummary{CheckNum,1}=SR_OutputDiff{i,1};
                    CheckSummary{CheckNum,2}='S/R输出接口';
                    if   strcmp(SR_OutputDiff{i,2},SR_OutputDiff{j,2})==0
                          CheckSummary{CheckNum,3}='Deviation---数据类型';
                    else
                          CheckSummary{CheckNum,3}='Deviation---维度';
                    end
                    CheckNum=CheckNum+1;
                    CheckSummaryFlag=1;
                    break;
                end
            elseif  strcmp(SR_OutputDiff{i,5},'New Have')
                if  strcmp(SR_OutputDiff{i,1},SR_OutputDiff{j,1}) && i~=j
                    CheckSummaryFlag=1;
                    break;
                end
            end
        end
        if  CheckSummaryFlag==0
            CheckSummary{CheckNum,1}=SR_OutputDiff{i,1};
            CheckSummary{CheckNum,2}='S/R输出接口';
            CheckSummary{CheckNum,3}=SR_OutputDiff{i,5};
            CheckNum=CheckNum+1;
        end
    end
end


%C/S接口，对比差异
CSSize=size(CSPortDiff);
if CSSize(1)>1
    for i=2:CSSize(1)
        CheckSummaryFlag=0;
        for j=2:CSSize(1)
            if  strcmp(CSPortDiff{i,5},'Old Have')
                if  strcmp(CSPortDiff{i,1},CSPortDiff{j,1}) && strcmp(CSPortDiff{j,5},'New Have')
                    CheckSummary{CheckNum,1}=CSPortDiff{i,1};
                    CheckSummary{CheckNum,2}='C/S接口';
                    if strcmp(CSPortDiff{i,2},CSPortDiff{j,2})==0
                       CheckSummary{CheckNum,3}='Deviation---函数名';
                    elseif strcmp(CSPortDiff{i,3},CSPortDiff{j,3})==0
                       CheckSummary{CheckNum,3}='Deviation---参数输入数据类型';
                    else
                       CheckSummary{CheckNum,3}='Deviation---返回值数据类型';   
                    end
                    CheckNum=CheckNum+1;
                    CheckSummaryFlag=1;
                    break;
                end
            elseif  strcmp(CSPortDiff{i,5},'New Have')
                if  strcmp(CSPortDiff{i,1},CSPortDiff{j,1}) && strcmp(CSPortDiff{j,5},'Old Have')
                    CheckSummaryFlag=1;
                    break;
                end
            end
        end
        
        if  CheckSummaryFlag==0
            CheckSummary{CheckNum,1}=CSPortDiff{i,1};
            CheckSummary{CheckNum,2}='C/S接口';
            CheckSummary{CheckNum,3}=CSPortDiff{i,5};
            CheckNum=CheckNum+1;
        end
    end
end


%子系统，对比差异
SystemSize=size(SystemDiff);
if SystemSize(1)>1
    for i=2:SystemSize(1)
        CheckSummaryFlag=0;
        for j=2:SystemSize(1)
            if  strcmp(SystemDiff{i,2},'Old Have')
            if  strcmp(SystemDiff{i,1},SystemDiff{j,1}) && strcmp(SystemDiff{j,2},'New Have')
                CheckSummary{CheckNum,1}=SystemDiff{i,1};
                CheckSummary{CheckNum,2}='Subsystem';
                CheckSummary{CheckNum,3}='Deviation偏差';
                CheckNum=CheckNum+1;
                CheckSummaryFlag=1;
                break;
            end
            elseif strcmp(SystemDiff{i,2},'New Have')
                if strcmp(SystemDiff{i,1},SystemDiff{j,1}) && i~=j
                   CheckSummaryFlag=1;
                end
            end
        end
        if  CheckSummaryFlag==0
            CheckSummary{CheckNum,1}=SystemDiff{i,1};
            CheckSummary{CheckNum,2}='Subsystem';
            CheckSummary{CheckNum,3}=SystemDiff{i,2};
            CheckNum=CheckNum+1;
        end
    end
end


%% 清除和显示
clearvars -except SR_InputDiff SR_OutputDiff CSPortDiff SystemDiff CheckSummary ModelNew_New  ModelNew_Old
close_system(ModelNew_New,[],'BreakUserLinks',true);
close_system(ModelNew_Old,[],'BreakUserLinks',true);
clearvars  ModelNew_New  ModelNew_Old
save('New_Old_Check');
clear;
clc;
disp('已完成：请查看New_Old_Check.mat中CheckSummary,各部分统计查看相应Diff');