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

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 $\dot{x}(t) = Ax(t) + Bu(t)$$x(0)=x_0$

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) = R^{-1} B^T P(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)=$\dot{P}(t) = -A^T P(t) - P(t) A + P(t) B R^{-1} B^T P(t) + Q$$P(t_f) = Q$

, B , x 0 , Q , Q f , R , t f são todos dados.$A$$B$$x_0$$Q$$Qf$$R$$t_f$

$x_0$$0$$t_f$$t_f$

$P(t)$$x(t)$$0$$t_f$$x(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?

$P(t)$$t \in [0,t_f]$

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).

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.

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.

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.