function [mk,meritF,stepp,stepd]=linesearch(r,nodeNum,balNode,pgNum,pvNum,pgvNum,xNum,transNum,pgNode,pvNode,m,x,y,z,l,u,w,G,B,transI,transJ,transG,...
    transB,transG1,transB1,Tn,capKn,capNum,capI,Tn1,capKn1,PG,QR,Pg,Qg,dx,dl,du,dy,dz,dw,opfGoal,Gama,Arlfa,meritF,k2,mu,T,capK,lineNum,lineI,...
    lineJ,Pd,Qd,gxx,gsx,mut,mub,stepp,stepd)
%程序功能：光滑处理过程，求步长
%编写时间：2010年11月

mk=0;
kk=k2;
isOK=0;
while isOK==0&&mk<10
    %更新临时变量
    xk=x+Arlfa.^mk*dx;
    lk=l+Arlfa.^mk*dl;
    uk=u+Arlfa.^mk*du;
    yk=y+Arlfa.^mk*dy;
    zk=z+Arlfa.^mk*dz;
    wk=w+Arlfa.^mk*dw;
    %更新临时控制变量和状态变量的值
    Tlastk=T;
    capKlastk=capK;
    T=xk(1:transNum,1);
    capK=xk(transNum+pgvNum+1:transNum+pgvNum+capNum);
    PG(pgNode,1)=xk(transNum+1:transNum+pgNum,1);
    QR(pvNode,1)=xk(transNum+pgNum+1:transNum+pgNum+pvNum,1);
    e=xk(transNum+pgNum+pvNum+capNum+1:transNum+pgNum+pvNum+capNum+nodeNum,1);
    f=xk(transNum+pgNum+pvNum+capNum+nodeNum+1:xNum,1);
    
    %变比变化后需修正节点导纳矩阵
    G=G-sparse(transI,transI,(T.*T-Tlastk.*Tlastk).*transG1,nodeNum,nodeNum)...
        +sparse(transI,transJ,transG1.*(T-Tlastk),nodeNum,nodeNum)...
        +sparse(transJ,transI,transG1.*(T-Tlastk),nodeNum,nodeNum);
    B=B-sparse(transI,transI,(T.*T-Tlastk.*Tlastk).*transB1,nodeNum,nodeNum)...
        +sparse(transI,transJ,transB1.*(T-Tlastk),nodeNum,nodeNum)...
        +sparse(transJ,transI,transB1.*(T-Tlastk),nodeNum,nodeNum)...
        +sparse(capI,capI,capK-capKlastk,nodeNum,nodeNum);
    %% 形成等式约束雅可比矩阵
    Ezu=exp(-(T-Tn)./mut);
    Ezu_1=exp(-(Tn1-T)./mut);
    dT_Zt=1;                                                                
    dNCPT=-mut.*log(Ezu+Ezu_1);                                             %变比对应的凝聚函数常数项
    dNCPT_dt=(Ezu-Ezu_1)./(Ezu+Ezu_1);                                      %凝聚函数对T求一次偏导
    transGmut=transG.*dT_Zt;
    transBmut=transB.*dT_Zt;
    
    Ezbu=exp((capKn-capK)./mub);
    Ezbu_1=exp((capK-capKn1)./mub);                                                            
    dNCPcap=-mub.*log(Ezbu+Ezbu_1);                                         %电容电抗器对应的凝聚函数常数项
    dNCP_dcap=(Ezbu-Ezbu_1)./(Ezbu+Ezbu_1);                                 %凝聚函数对capK求一次偏导

    ef1=e(transI).*e(transJ)+f(transI).*f(transJ);
    ef2=e(transI).*f(transJ)-e(transJ).*f(transI);
    ef3=e(transI).*e(transI)+f(transI).*f(transI);
    ef1G=ef1.*transGmut;
    ef1B=ef1.*transBmut;
    ef2G=ef2.*transGmut;
    ef2B=ef2.*transBmut;
    dhPTi=-ef1G+ef2B+2*ef3.*transGmut.*T;
    dhPTj=-ef1G-ef2B;
    dhPT=sparse(1:transNum,transI,dhPTi,transNum,nodeNum)+sparse(1:transNum,transJ,dhPTj,transNum,nodeNum);%有功平衡方程P对变压器变比求偏导
    dhQTi=ef1B+ef2G-2*ef3.*transBmut.*T;
    dhQTj=ef1B-ef2G;
    dhQT=sparse(1:transNum,transI,dhQTi,transNum,nodeNum)+sparse(1:transNum,transJ,dhQTj,transNum,nodeNum);%无功平衡方程Q对变压器变比求偏导
    dhNCP_T=sparse(1:transNum,1:transNum,dNCPT_dt,transNum,transNum+capNum);
    dhP=sparse(1:pgNum,pgNode,ones(pgNum,1),pgNum,m);
    dhQ1=sparse(1:pvNum,pvNode,ones(pvNum,1),pvNum,m-nodeNum);
    dhQ=[sparse(pvNum,nodeNum) dhQ1];
    dhcapK1=sparse(1:capNum,capI,(e(capI).^2+f(capI).^2),capNum,nodeNum);   %2011年10月5日修改，去掉.*capBi_dBci
    dhNCP_capK=sparse(1:capNum,transNum+1:transNum+capNum,dNCP_dcap,capNum,transNum+capNum);
    dhcapK=[sparse(capNum,nodeNum) dhcapK1 dhNCP_capK];
    %形成功率方程雅可比矩阵
    H1=G*e-B*f;
    N1=G*f+B*e;
    diagE=sparse(1:nodeNum,1:nodeNum,e,nodeNum,nodeNum);
    diagF=sparse(1:nodeNum,1:nodeNum,f,nodeNum,nodeNum);
    deG=diagE*G;
    dfB=diagF*B;
    deB=diagE*B;
    dfG=diagF*G;
    dH1=sparse(1:nodeNum,1:nodeNum,H1,nodeNum,nodeNum);
    dN1=sparse(1:nodeNum,1:nodeNum,N1,nodeNum,nodeNum);
    Hij=-dH1-deG-dfB;
    Nij=-dN1+deB-dfG;
    Jij=dN1-dfG+deB;
    Lij=-dH1+dfB+deG;
    dhJacb=[Hij Nij;Jij Lij]';                                              %合并形成功率方程的雅可比矩阵  
    dhT=[dhPT dhQT dhNCP_T];                                                %合并形成等式约束雅可比矩阵h(x)
    dhx=[dhT;dhP;dhQ;dhcapK;dhJacb sparse(2*nodeNum,transNum+capNum)];
    %% 形成不等式约束雅可比矩阵▽g(x)
    gtransNum=0;                                                            %变比上下限约束维数，用NCP函数后，则不需要再约束其上下限
    gcapNum=0;
    dgT1=sparse(transNum,r-lineNum);
    dglT=(e(transI).^2+f(transI).^2-e(transI).*e(transJ)-f(transI).*f(transJ)).*transGmut+(e(transI).*f(transJ)-e(transJ).*f(transI)).*transBmut; 
    dgT2=sparse(1:transNum,lineNum-transNum+1:lineNum,dglT,transNum,lineNum); 
    dgT=[dgT1 dgT2];                                                        %所有不等式约束对T求导的模块
    dgP=sparse(1:pgNum,gtransNum+1:gtransNum+pgNum,ones(pgNum,1),pgNum,r);  %所有不等式约束对P求导的模块
    dgQ=sparse(1:pvNum,gtransNum+pgNum+1:gtransNum+pgvNum,ones(pvNum,1),pvNum,r);%所有不等式约束对Q求导的模块
    dgcapK=sparse(capNum,r);                                                %所有不等式约束对capK求导的模块
    dgve=2*diagE;
    dgvf=2*diagF;
    sizeG=size(G);
    GIJ=G(sub2ind(sizeG,lineI,lineJ));
    BIJ=B(sub2ind(sizeG,lineI,lineJ));
    dgleI=(2*e(lineI)-e(lineJ)).*GIJ+f(lineJ).*BIJ;
    dgleJ=-e(lineI).*GIJ-f(lineI).*BIJ;
    dglfI=(2*f(lineI)-f(lineJ)).*GIJ-e(lineJ).*BIJ;
    dglfJ=-f(lineI).*GIJ+e(lineI).*BIJ;
    dgle=sparse(lineI,(1:lineNum),dgleI,nodeNum,lineNum)+sparse(lineJ,(1:lineNum),dgleJ,nodeNum,lineNum);
    dglf=sparse(lineI,(1:lineNum),dglfI,nodeNum,lineNum)+sparse(lineJ,(1:lineNum),dglfJ,nodeNum,lineNum);
    dg0=sparse(2*nodeNum,gtransNum+pgvNum+gcapNum);
    dgvl=[dgve dgle;dgvf dglf];
    dgef=[dg0 dgvl];                                                        %所有不等式约束对电压实部、虚部求偏导的模块
    dgx=[dgT;dgP;dgQ;dgcapK;dgef];                                          %不等式约束雅克比矩阵
    %% 形成对角阵
    Z=sparse(1:r,1:r,zk,r,r);
    W=sparse(1:r,1:r,wk,r,r);
    L1=sparse(1:r,1:r,1./lk,r,r);
    U1=sparse(1:r,1:r,1./uk,r,r);
    LZ=L1*Z;
    UW=U1*W;
    Ll=(lk.*zk-mu*ones(r,1));
    Lu=(uk.*wk+mu*ones(r,1));
    
    %% 形成目标函数一阶偏导矩阵▽f(.)
    if(opfGoal==2)
        dPG=ones(pgNum,1);
        dfx=sparse(transNum+1:transNum+pgNum,ones(pgNum,1),dPG,xNum,1);
    else if(opfGoal==1)
            dPG=2*a(pgNode).*PG(pgNode)+b(pgNode);
            dfx=sparse(transNum+1:transNum+pgNum,ones(pgNum,1),dPG,xNum,1);
        else if(opfGoal==3)
                dfT=-1*transG.*dT_Zt.*((f(transI)-f(transJ)).^2+(e(transI)-e(transJ)).^2);
                dfPQ=zeros(pgvNum,1);
                dfcapK=zeros(capNum,1);
                EE=e*ones(1,nodeNum);
                FF=f*ones(1,nodeNum);
                dfe=2*sum(G.*(EE-EE'));
                dff=2*sum(G.*(FF-FF'));
                dfx=[dfT;dfPQ;dfcapK;dfe';dff'];
            else if(opfGoal==4)
                    dfT=1*transB.*dT_Zt.*((f(transI)-f(transJ)).^2+(e(transI)-e(transJ)).^2);
                    dfPQ=zeros(pgvNum,1);
                    dfcapK=zeros(capNum,1);
                    EE=e*ones(1,nodeNum);
                    FF=f*ones(1,nodeNum);
                    dfe=-2*sum(B.*(EE-EE'));
                    dff=-2*sum(B.*(FF-FF'));
                    dfx=[dfT;dfPQ;dfcapK;dfe';dff'];
                end
            end
        end
    end
    %% 不等式约束项
    gxv=[PG(pgNode);QR(pvNode);e.^2+f.^2];                                 
    gxl=(e(lineI).*e(lineI)+f(lineI).*f(lineI)-e(lineI).*e(lineJ)-f(lineI).*f(lineJ)).*GIJ+(e(lineI).*f(lineJ)-e(lineJ).*f(lineI)).*BIJ;%线路功率当前值
    gx=[gxv;gxl];                                                            %约束条件当前值
    Lz=gx-lk-gxx;
    Lw=gx+uk-gsx;
    muUL=mu*(U1-L1);
    BB1=UW*Lw-LZ*Lz-muUL*ones(r,1);
    BB=dhx*yk-dfx+dgx*BB1;
    BB(transNum+pgvNum+capNum+nodeNum+balNode,1)=0;                         %保持平衡节点电压虚部不变，始终为0，则常数项平衡节点处置0
    BB(transNum+pgvNum+capNum+balNode,1)=0;
    %% 等式约束不平衡量
    Pg(pgNode)=PG(pgNode);
    Qg(pvNode)=QR(pvNode);
    P=Pg-Pd;
    Q=Qg-Qd;
    dP=P-diagE*H1-diagF*N1;
    dQ=Q-diagF*H1+diagE*N1;
    
    hx=[dP;dQ;dNCPT;dNCPcap];                                               %修正方程常数项h(x)
    const=[BB;hx];                                                          %修正方程常数项向量
    L3=-L1*(Z*Lz+Ll);
    L4=U1*(W*Lw-Lu);
    L5=Lz;
    L6=Lw;
    f_NCP=[const;L3;L4;L5;L6];
    f_NCPsum=(f_NCP'*f_NCP)/2;
    maxfk=max(meritF(kk-min(10,kk)+1:end));
    f3=maxfk-Gama*(Arlfa.^mk)*meritF(kk);
    if f_NCPsum<=f3
        isOK=1;                                                             %满足条件，跳出
    else
        mk=mk+1;                                                            %不满足条件，继续搜索
    end
end
stepp=stepp*Arlfa.^mk;
stepd=stepd*Arlfa.^mk;