function [sys,x0,str,ts] = UPFCModel2(t,x,u,flag,ku1,ku2,PTs,Eq1s,USs,wN,UCs,PLs,QLs,aEqs,UAs,X1,x2,X3,X31,xl,xT2,K)

switch flag,

  %%%%%%%%%%%%%%%%%%
  % Initialization %
  %%%%%%%%%%%%%%%%%%
  case 0,
    [sys,x0,str,ts]=mdlInitializeSizes(t,x,u);

  %%%%%%%%%%%%%%%
  % Derivatives %
  %%%%%%%%%%%%%%%
  case 1,
    sys=mdlDerivatives(t,x,u);

  %%%%%%%%%%
  % Update %
  %%%%%%%%%%
  case 2,
    sys=mdlUpdate(t,x,u);

  %%%%%%%%%%%
  % Outputs %
  %%%%%%%%%%%
case 3,
   sys=mdlOutputs(t,x,u,ku1,ku2,PTs,Eq1s,USs,wN,UCs,PLs,QLs,aEqs,UAs,X1,x2,X3,X31,xl,xT2,K);
  %%%%%%%%%%%%%%%%%%%%%%%
  % GetTimeOfNextVarHit %
  %%%%%%%%%%%%%%%%%%%%%%%
  case 4,
    sys=mdlGetTimeOfNextVarHit(t,x,u);

  %%%%%%%%%%%%%
  % Terminate %
  %%%%%%%%%%%%%
  case 9,
    sys=mdlTerminate(t,x,u);

  %%%%%%%%%%%%%%%%%%%%
  % Unexpected flags %
  %%%%%%%%%%%%%%%%%%%%
  otherwise
    error(['Unhandled flag = ',num2str(flag)]);

end

% end sfuntmpl
function [sys,x0,str,ts]=mdlInitializeSizes(t,x,u)
sizes = simsizes;
sizes.NumContStates  = 0;
sizes.NumDiscStates  = 0;
sizes.NumOutputs     = 9;
sizes.NumInputs      = 8;
sizes.DirFeedthrough = 0;
sizes.NumSampleTimes = 1;   % at least one sample time is needed

sys = simsizes(sizes);

%
% initialize the initial conditions
%
x0  = [];

%
% str is always an empty matrix
%
str = [];

%
% initialize the array of sample times
%
ts  = [0 0];

% end mdlInitializeSizes

%
%=============================================================================
% mdlDerivatives
% Return the derivatives for the continuous states.
%=============================================================================
%
function sys=mdlDerivatives(t,x,u)
sys=[];
% end mdlDerivatives

%
%=============================================================================
% mdlUpdate
% Handle discrete state updates, sample time hits, and major time step
% requirements.
%=============================================================================
%
function sys=mdlUpdate(t,x,u)

sys = [];

% end mdlUpdate

%
%=============================================================================
% mdlOutputs
% Return the block outputs.
%=============================================================================
%
function sys=mdlOutputs(t,x,u,ku1,ku2,PTs,Eq1s,USs,wN,UCs,PLs,QLs,aEqs,UAs,X1,x2,X3,X31,xl,xT2,K)

U1=ku1*u(6)*cos(u(1));
U2=ku2*u(6)*cos(u(3));


if(t>=0.1&t<0.3)
   X2=x2+xl;
   Xpg=1/X2+1/X1+1/X3;
   zz=-X3*(X3-X31)/(X1*X2*(X3-X31+X3*X31*Xpg));
   
Eq=zz*(X1*U2*cos(u(4)-u(5))+X2*U1*cos(u(2)-u(5)))-zz*X1*X2*X3*Xpg*Eq1s/(X3-X31);
UAx=1/Xpg*(Eq*cos(u(5))/X3+U1*cos(u(2))/X1+U2*cos(u(4))/X2);
UAy=1/Xpg*(Eq*sin(u(5))/X3+U1*sin(u(2))/X1+U2*sin(u(4))/X2);

Pe=(Eq*sin(u(5))*UAx-Eq*cos(u(5))*UAy)/X3;
P1=(U1*cos(u(2))*UAy-U1*sin(u(2))*UAx)/X1;
P2=(U2*cos(u(4))*UAy-U2*sin(u(4))*UAx)/X2;
PC=P1+P2;
UA=sqrt(UAx^2+UAy^2);
I2x=(UAy-U2*sin(u(4)))/X2;
I2y=(U2*cos(u(4))-UAx)/X2;
UBx=0;
UBy=0;
PL=UBx*I2x+UBy*I2y;
QL=UBy*I2x-UBx*I2y;
elseif(t>=0.3&t<1.3)
     xll=2*xl;
     X2=xll+x2+xT2;
   Xpg=1/X2+1/X1+1/X3;
   zz=-X3*(X3-X31)/(X1*X2*(X3-X31+X3*X31*Xpg));
   
Eq=zz*(X1*U2*cos(u(4)-u(5))+X2*U1*cos(u(2)-u(5))+X1*USs*cos(u(5)))-zz*X1*X2*X3*Xpg*Eq1s/(X3-X31);
UAx=1/Xpg*(Eq*cos(u(5))/X3+U1*cos(u(2))/X1+(U2*cos(u(4))+USs)/X2);
UAy=1/Xpg*(Eq*sin(u(5))/X3+U1*sin(u(2))/X1+U2*sin(u(4))/X2);

Pe=(Eq*sin(u(5))*UAx-Eq*cos(u(5))*UAy)/X3;
P1=(U1*cos(u(2))*UAy-U1*sin(u(2))*UAx)/X1;
P2=(U2*cos(u(4))*UAy-U2*sin(u(4))*UAx+U2*sin(u(4))*USs)/X2;
PC=P1+P2;
UA=sqrt(UAx^2+UAy^2);
I2x=(UAy-U2*sin(u(4)))/X2;
I2y=(USs+U2*cos(u(4))-UAx)/X2;
UBx=USs-I2y*(xl+xT2);
UBy=I2x*(xl+xT2);
PL=UBx*I2x+UBy*I2y;
QL=UBy*I2x-UBx*I2y;
else
        X2=xl+x2+xT2;
   Xpg=1/X2+1/X1+1/X3;
   zz=-X3*(X3-X31)/(X1*X2*(X3-X31+X3*X31*Xpg));
   
Eq=zz*(X1*U2*cos(u(4)-u(5))+X2*U1*cos(u(2)-u(5))+X1*USs*cos(u(5)))-zz*X1*X2*X3*Xpg*Eq1s/(X3-X31);
UAx=1/Xpg*(Eq*cos(u(5))/X3+U1*cos(u(2))/X1+(U2*cos(u(4))+USs)/X2);
UAy=1/Xpg*(Eq*sin(u(5))/X3+U1*sin(u(2))/X1+U2*sin(u(4))/X2);

Pe=(Eq*sin(u(5))*UAx-Eq*cos(u(5))*UAy)/X3;
P1=(U1*cos(u(2))*UAy-U1*sin(u(2))*UAx)/X1;
P2=(U2*cos(u(4))*UAy-U2*sin(u(4))*UAx+U2*sin(u(4))*USs)/X2;
PC=P1+P2;
UA=sqrt(UAx^2+UAy^2);
I2x=(UAy-U2*sin(u(4)))/X2;
I2y=(USs+U2*cos(u(4))-UAx)/X2;
UBx=USs-I2y*(xl+xT2);
UBy=I2x*(xl+xT2);
PL=UBx*I2x+UBy*I2y;
QL=UBy*I2x-UBx*I2y;


end



%dPL=PL-PLs;
dPL=PL-u(8);
dQL=QL-QLs;
dPC=PC-0;
dUA=UA-UAs;
daEq=u(5)-aEqs;
dUC=u(6)-UCs;
dw=u(7)-wN;
dx=[dPL;dQL;dPC;dUA;daEq;dUC;dw];
du=-K*dx;
ur1=du(1);ua1=du(2);ur2=du(3);ua2=du(4);
aI=atan(I2y/I2x);

sys=[ur1;ua1;ur2;ua2;PC;Pe;UA;QL;aI];

% end mdlOutputs

%
%=============================================================================
% mdlGetTimeOfNextVarHit
% Return the time of the next hit for this block.  Note that the result is
% absolute time.  Note that this function is only used when you specify a
% variable discrete-time sample time [-2 0] in the sample time array in
% mdlInitializeSizes.
%=============================================================================
%
function sys=mdlGetTimeOfNextVarHit(t,x,u)

sampleTime = 1;    %  Example, set the next hit to be one second later.
sys = t + sampleTime;

% end mdlGetTimeOfNextVarHit

%
%=============================================================================
% mdlTerminate
% Perform any end of simulation tasks.
%=============================================================================
%
function sys=mdlTerminate(t,x,u)

sys = [];

% end mdlTerminate