résolution des ODE couplés avec des contraintes de valeur initiale et de valeur finale

L'essence de ma question est la suivante: j'ai un système de deux ODE. L'un a une contrainte de valeur initiale et l'autre une contrainte de valeur finale. Cela peut être considéré comme un système unique avec une contrainte de valeur initiale sur certaines variables et une contrainte de valeur finale sur les autres.

Voici les détails:

J'essaie d'utiliser un contrôleur LQR à horizon fini en temps continu pour piloter un système dynamique linéaire. J'aimerais continuer à utiliser l'écosystème Python.

Le système est sous la forme , sous réserve de x ( 0 ) = x $\dot{x}(t) = Ax(t) + Bu(t)$$x(0)=x_0$

La solution LQR génère une matrice telle que l'entrée de commande optimale u (t), linéaire en x ( t ) , est u ( t ) = K ( t ) x ( t ) .$K(t)$$x(t)$$u(t) = K(t)x(t)$

où $K(t) = R^{-1} B^T P(t)$

et est la solution à une équation différentielle de Riccati à temps continu (notez que ce P ( t ) est une matrice)$P(t)$$P(t)$

sous réserve deP(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 sont tous donnés.$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)$. Cela m'inquiète car le solveur numérique ODE pour x (t) n'échantillonnera pas nécessairement l'ODE en même temps que les temps dans la solution numérique de $ P (t). Peut-être existe-t-il un moyen intelligent de faire respecter cela.

L'autre façon que je prévois de résoudre le problème est de résoudre le système ensemble, mais je ne sais pas comment gérer le mélange de contraintes de valeur initiale et de valeur finale. Ces problèmes sont-ils lourds à résoudre sur le plan informatique? Puis-je le faire dans SciPy / Python?

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

Vous pouvez le faire en interpolant entre les valeurs de sortie . Je vous recommande d'utiliser une méthode Runge-Kutta qui prend en charge une sortie dense. Par exemple, scipy.integrate.ode.dopri5est basé sur une telle méthode. Vous devriez donc être en mesure de spécifier des temps de sortie très finement espacés sans forcer l'intégrateur à prendre de très petites étapes (en supposant que l'interface scipy à celui-ci est implémentée correctement).

Ceci est appelé un problème de valeur limite à deux points et est bien étudié.

La méthode de prise de vue est très simple à programmer mais peut être extrêmement instable numériquement.

La manière standard de résoudre ces problèmes consiste à utiliser une approche de prise de vue multiple et à résoudre le système d'équations non linéaire correspondant par un solveur non linéaire standard. Pour une liste des solveurs pour les systèmes d'équations non linéaires, voir, par exemple,
http://www.mat.univie.ac.at/~neum/glopt/software_l.html#nonlin

Vous prenez comme variables les états d'une grille régulière dans le temps (généralement aucune grille très fine n'est nécessaire), et comme équations les conditions aux limites et les mappages qui mappent les variables de temps t aux variables de temps t + h. Cela donne autant d'équations que de variables. Il vous suffit de fournir les routines pour évaluer ce mappage pour une configuration donnée d'états sur la grille, et le solveur non linéaire fait tout le reste. (Peut-être avez-vous besoin de plusieurs points de départ si vos suppositions initiales sont mauvaises.)

Wikipedia http://en.wikipedia.org/wiki/Direct_multiple_shooting_method a une description utile du processus, si la description ci-dessus n'est pas assez détaillée pour vous. Le livre de Stoer / Bulirsch qui y est cité donne tous les détails.

Je ne sais pas comment le faire en Python, mais le mot-clé que vous souhaitez rechercher dans la littérature est la "méthode de prise de vue". C'est le nom d'une méthode qui résout les problèmes qui ont des contraintes de valeur initiale et finale.

AUTO peut résoudre deux points BVP et possède une interface python et est relativement facile à installer. http://www.ma.hw.ac.uk/~gabriel/auto07/node6.html .

Si vous choisissez d'abord de résoudre P (t) et de le transmettre à l'autre ODE en tant qu'entrée, alors un moyen efficace de le configurer est d'utiliser PyDSTool. PyDSTool est très facile à installer sur n'importe quelle plateforme, voir http://pydstool.sf.net . Par défaut, il n'utilisera que l'interpolation linéaire pour votre solution précédemment calculée (donc calculez-la à une résolution temporelle fine). Cependant, vous pouvez forcer PyDSTool à atteindre exactement les points temporels souhaités même avec un intégrateur adaptatif (bien que cela puisse être inefficace et conduire à des inexactitudes). Mais avec des pas de temps max suffisamment petits, l'interpolation linéaire et un intégrateur rapide (Dopri est intégré) pour le deuxième système signifie que vous irez bien pour des systèmes "réguliers" comme celui-ci.