resolução de EDOs acopladas com restrições de valor inicial e final

11

A essência da minha pergunta é a seguinte: Eu tenho um sistema de dois EDOs. Um tem uma restrição de valor inicial e o outro tem uma restrição de valor final. Isso pode ser pensado como um sistema único com uma restrição de valor inicial em algumas variáveis ​​e uma restrição de valor final em outras.

Aqui estão os detalhes:

Estou tentando usar um controlador LQR de horizonte finito de tempo contínuo para conduzir um sistema dinâmico linear. Eu gostaria de continuar usando o ecossistema Python.

O sistema está na forma , sujeito a x ( 0 ) = x 0x˙(t)=Ax(t)+Bu(t)x(0)=x0

A solução LQR gera uma matriz modo que a entrada de controle ideal u (t), linear em x ( t ) , seja u ( t ) = K ( t ) x ( t ) .K(t)x(t)u(t)=K(t)x(t)

onde K(t)=R1BTP(t)

e é a solução para uma equação diferencial de Riccati em tempo contínuo (observe que este P ( t ) é uma matriz)P(t)P(t)

sujeito aP(tf)=QP˙(t)=ATP(t)P(t)A+P(t)BR1BTP(t)+QP(tf)=Q

, B , x 0 , Q , Q f , R , t f são todos dados.ABx0QQfRtf

x00tftf

P(t)x(t)0tfx(t). Isso me preocupa porque o solucionador numérico de ODE para x (t) não necessariamente amostrará o ODE nos mesmos horários que os tempos na solução numérica para $ P (t). Talvez haja alguma maneira inteligente de fazer isso.

A outra maneira que prevejo resolver o problema é resolver o sistema juntos, mas não sei como lidar com a mistura de restrições de valor inicial e final. Esses problemas computacionalmente são pesados ​​para resolver? Posso fazer isso no SciPy / Python?

Gus
fonte

Respostas:

8

P(t)t[0,tf]

Você pode fazer isso interpolando entre os valores de saída . Eu recomendo que você use um método Runge-Kutta que suporte saída densa. Por exemplo, scipy.integrate.ode.dopri5é baseado nesse método. Portanto, você deve poder especificar tempos de saída muito bem espaçados sem forçar o integrador a executar etapas muito pequenas (supondo que a interface do scipy seja implementada corretamente).

David Ketcheson
fonte
P(t)P(t)
6

Isso é chamado de problema de valor de limite de dois pontos e é bem estudado.

O método de disparo é muito simples de programar, mas pode ser extremamente instável numericamente.

A maneira padrão de resolver esses problemas é usar uma abordagem de disparo múltiplo e resolver o sistema não-linear de equações correspondente por um solucionador não-linear padrão. Para obter uma lista de solucionadores de sistemas não lineares de equações, consulte, por exemplo,
http://www.mat.univie.ac.at/~neum/glopt/software_l.html#nonlin

Você toma como variáveis ​​os estados em uma grade regular no tempo (geralmente nenhuma grade muito fina é necessária) e como equações as condições de contorno e os mapeamentos que mapeiam as variáveis ​​de tempo t para as variáveis ​​de tempo t + h. Isso fornece tantas equações quanto variáveis. Você só precisa fornecer as rotinas para avaliar esse mapeamento para uma determinada configuração de estados na grade, e o solucionador não linear faz todo o resto. (Talvez você precise de vários pontos de partida se suas estimativas iniciais forem ruins.)

A Wikipedia http://en.wikipedia.org/wiki/Direct_multiple_shooting_method possui uma descrição útil do processo, se a descrição acima não for detalhada o suficiente para você. O livro de Stoer / Bulirsch, citado lá, fornece detalhes completos.

Arnold Neumaier
fonte
5

Não sei como fazê-lo em Python, mas a palavra-chave que você deseja procurar na literatura é o "método de disparo". Esse é o nome de um método que resolve problemas com restrições de valor inicial e final.

Wolfgang Bangerth
fonte
1

O AUTO pode resolver BVPs de dois pontos e possui uma interface python e é relativamente fácil de instalar. http://www.ma.hw.ac.uk/~gabriel/auto07/node6.html .

Se você seguir o caminho de querer resolver P (t) primeiro e alimentá-lo com o outro ODE como entrada, uma maneira eficiente de configurá-lo é usando o PyDSTool. O PyDSTool é muito fácil de instalar em qualquer plataforma, consulte http://pydstool.sf.net . Por padrão, ele usará apenas interpolação linear para sua solução previamente calculada (então calcule isso em resolução de tempo preciso). No entanto, você pode forçar o PyDSTool a avançar exatamente para os pontos de tempo desejados, mesmo com um integrador adaptável (embora isso possa ser ineficiente e levar a imprecisões). Mas com etapas de tempo máximo pequenas o suficiente, a interpolação linear e um integrador rápido (o Dopri está embutido) para o segundo sistema significa que você ficará bem em sistemas "regulares" como esse.

RHC
fonte