odedc

Parâmetros

y0

vetor coluna de reais (condições iniciais), y0=[y0c;y0d] onde y0d tem nd componentes.

nd

inteiro, dimensão de y0d

stdel

vetor de reais com uma ou duas entradas, stdel=[h, delta] (com delta=0 como valor padrão).

t0

escalar real (tempo inicial).

t

vetor (linha de reais), instantes onde yt é calculado .

f

função externa i.e. função, string ou lista com seqüência de chamamento: yp=f(t,yc,yd,flag).

Descrição

y=odedc([y0c;y0d],nd,[h,delta],t0,t,f) computa a solução de um sistema misto contínuo/discreto. O estado de sistema discreto yd_k é embutido em uma função de tempo seccional constante yd(t) como segue:

yd(t)=yd_k para t em
[t_k=atraso+k*h,t_(k+1)=delay+(k+1)*h] (com atraso=h*delta).

As equações simuladas são agora:

dyc/dt=f(t,yc(t),yd(t),0),  para t em [t_k,t_(k+1)]
yc(t0)=y0c

e nos instantes t_k a variável discreta yd é atualizada por:

yd(t_k+)=f(yc(t_k-),yd(t_k-),1)

Note que, utilizando a definição de yd(t), a última equação fornece

yd_k = f (t_k,yc(t_k-),yd(t_(k-1)),1)  (yc é de tempo contínuo: yc(t_k-)=yc(tk))

Os parâmetros de chamada de f são fixados: ycd=f(t,yc,yd,flag); esta função deve retornar a derivada do vetor yc se flag=0 ou a atualização de yd se flag=1.

ycd=dot(yc) deve ser um vetor de mesma dimensão que yc se flag=0 e ycd=update(yd) deve ser um vetor com a mesma dimensão que yd se flag=1.

t é um vetor de constantes onde a solução y é computada.

y é o vetor y=[y(t(1)),y(t(2)),...].

Esta função pode ser chamada com os mesmo parâmetro opcionais da função ode (desde que nd e stdel sejam dados na seqüência de chamamento como segundo e terceiro parâmetros). Em particular, flags de integração e tolerâncias podem ser ajustadas. Parâmetros opcionais podem ser ajustados pela função odeoptions.

Um exemplo para chamada de rotina externa é encontrado em SCIDIR/default/fydot2.f

Rotinas externas podem ser ligadas dinamicamente (ver link).

Exemplos

//sistema linear com entrada alternante
deff('xdu=phis(t,x,u,flag)','if flag==0 then xdu=A*x+B*u; else xdu=1-u;end');
x0=[1;1];A=[-1,2;-2,-1];B=[1;2];u=0;nu=1;stdel=[1,0];u0=0;t=0:0.05:10;
xu=odedc([x0;u0],nu,stdel,0,t,phis);x=xu(1:2,:);u=xu(3,:);
nx=2;
plot2d(t, x', [1:nx],'161')
plot2d2('onn',t',u',[nx+1:nx+nu],'000');

//função externa FORTRAN (ver fydot2.f):
norm(xu-odedc([x0;u0],nu,stdel,0,t,'phis'),1)

//feedback (resposta) amostrado
//
//        |     xcdot=fc(t,xc,u)
//  (sistema)   |
//        |     y=hc(t,xc)
//
//
//        |     xd+=fd(xd,y)
//  (feedback) |
//        |     u=hd(t,xd)
//
deff('xcd=f(t,xc,xd,iflag)',...
  ['if iflag==0 then '
   '  xcd=fc(t,xc,e(t)-hd(t,xd));'
   'else '
   '  xcd=fd(xd,hc(t,xc));'
   'end']);
A=[-10,2,3;4,-10,6;7,8,-10];B=[1;1;1];C=[1,1,1];
Ad=[1/2,1;0,1/20];Bd=[1;1];Cd=[1,1];
deff('st=e(t)','st=sin(3*t)')
deff('xdot=fc(t,x,u)','xdot=A*x+B*u')
deff('y=hc(t,x)','y=C*x')
deff('xp=fd(x,y)','xp=Ad*x + Bd*y')
deff('u=hd(t,x)','u=Cd*x')
h=0.1;t0=0;t=0:0.1:2;
x0c=[0;0;0];x0d=[0;0];nd=2;
xcd=odedc([x0c;x0d],nd,h,t0,t,f);
norm(xcd-odedc([x0c;x0d],nd,h,t0,t,'fcd1')) // cálculo rápido (ver fydot2.f)
plot2d([t',t',t'],xcd(1:3,:)');
scf(2);
plot2d2("gnn",[t',t'],xcd(4:5,:)');
scf(0);

Ver Também

• ode — Solucionador de equações diferenciais ordinárias
• link — dynamic linker
• odeoptions — ajusta opções para solucionadores de EDO
• csim — simulation (time response) of linear system
• external — objeto Scilab, função ou rotina externa