resolución de EDO acopladas con restricciones de valor inicial y de valor final

La esencia de mi pregunta es la siguiente: tengo un sistema de dos EDO. Uno tiene una restricción de valor inicial y el otro tiene una restricción de valor final. Esto puede considerarse como un sistema único con una restricción de valor inicial en algunas variables y una restricción de valor final en otras.

Aquí están los detalles:

Estoy tratando de usar un controlador LQR de horizonte finito de tiempo continuo para conducir un sistema dinámico lineal. Me gustaría seguir usando el ecosistema de Python.

El sistema tiene la forma , sujeto ax(0)=x$\dot{x}(t) = Ax(t) + Bu(t)$$x(0)=x_0$

La solución LQR genera una matriz tal que la entrada de control óptima u (t), lineal en , es .x ( t ) u ( t ) = K ( t ) x ( t $K(t)$$x(t)$$u(t) = K(t)x(t)$

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

y es la solución a una ecuación diferencial de Riccati de tiempo continuo (tenga en cuenta que este es una matriz)P ( t $P(t)$$P(t)$

P(tf)=$\dot{P}(t) = -A^T P(t) - P(t) A + P(t) B R^{-1} B^T P(t) + Q$ sujeto a$P(t_f) = Q$

B x 0 Q Q f R t $A$ , , , , , , se dan todos.$B$$x_0$$Q$$Qf$$R$$t_f$

En inglés: tiene un sistema dinámico que comienza en el estado . El controlador LQR genera una matriz de retroalimentación para usar entre el tiempo y ( se denomina comúnmente horizonte temporal del problema) 0 t f t $x_0$$0$$t_f$$t_f$

Tenga en cuenta que las dos EDO están acopladas solo en una dirección: la solución a no depende de . Por lo tanto, una forma de resolver el problema es invertir la ecuación de Riccati para convertir el problema del valor final en un problema de valor inicial y encontrar una solución numérica entre el tiempo y usando un integrador ODE estándar. Entonces puedo usar esta solución numérica para encontrar . Esto me preocupa porque el solucionador numérico de ODE para x (t) no necesariamente muestreará el ODE al mismo tiempo que los tiempos en la solución numérica de $ P (t). Tal vez hay alguna forma inteligente de hacer cumplir esto.x ( t ) 0 t f x ( t $P(t)$$x(t)$$0$$t_f$$x(t)$

La otra forma en que preveo resolver el problema es resolver el sistema juntos, pero no sé cómo lidiar con la combinación de restricciones de valor inicial y de valor final. ¿Son estos problemas computacionalmente pesados ​​de resolver? ¿Puedo hacerlo en SciPy / Python?

No estoy de acuerdo con las otras respuestas. Como solo tiene un acoplamiento unidireccional entre los problemas de tiempo inverso y avance, será mucho más eficiente resolverlos en secuencia, como propone primero. Simplemente necesita una solución que pueda evaluarse en cualquier momento . t ∈ [ 0 , t f$P(t)$$t \in [0,t_f]$

Puede hacer esto interpolando entre los valores de salida . Le recomiendo que utilice un método Runge-Kutta que admita una salida densa. Por ejemplo, scipy.integrate.ode.dopri5se basa en tal método. Por lo tanto, debería poder especificar tiempos de salida muy finamente espaciados sin obligar al integrador a tomar pasos muy pequeños (suponiendo que la interfaz scipy se implemente correctamente).

Esto se llama un problema de valor límite de dos puntos y está bien estudiado.

El método de disparo es muy sencillo de programar, pero puede ser extremadamente inestable numéricamente.

La forma estándar de resolver estos problemas es usar un enfoque de disparo múltiple y resolver el sistema de ecuaciones no lineal correspondiente mediante un solucionador no lineal estándar. Para obtener una lista de solucionadores para sistemas de ecuaciones no lineales, consulte, por ejemplo,
http://www.mat.univie.ac.at/~neum/glopt/software_l.html#nonlin

Toma como variables los estados en una cuadrícula regular en el tiempo (generalmente no se necesita una cuadrícula muy fina), y como ecuaciones las condiciones de contorno y las asignaciones que asignan las variables de tiempo t a las variables de tiempo t + h. Esto da tantas ecuaciones como variables. Solo necesita proporcionar las rutinas para evaluar esta asignación para una configuración dada de estados en la cuadrícula, y el solucionador no lineal hace todo lo demás. (Quizás necesite múltiples puntos de partida si sus conjeturas iniciales son malas).

Wikipedia http://en.wikipedia.org/wiki/Direct_multiple_shooting_method tiene una descripción útil del proceso, si la descripción anterior no es lo suficientemente detallada para usted. El libro de Stoer / Bulirsch citado allí brinda detalles completos.

No sé cómo hacerlo en Python, pero la palabra clave que desea buscar en la literatura es el "método de disparo". Ese es el nombre de un método que resuelve problemas que tienen restricciones de valor inicial y final.

AUTO puede resolver BVP de dos puntos y tiene una interfaz de Python y es relativamente fácil de instalar. http://www.ma.hw.ac.uk/~gabriel/auto07/node6.html .

Si sigue la ruta de querer resolver P (t) primero y alimentarlo al otro ODE como entrada, entonces una forma eficiente de configurarlo es usando PyDSTool. PyDSTool es muy fácil de instalar en cualquier plataforma, consulte http://pydstool.sf.net . De forma predeterminada, solo usará interpolación lineal para su solución previamente calculada (así que calcule eso con una resolución de tiempo precisa). Sin embargo, puede obligar a PyDSTool a avanzar exactamente a los puntos de tiempo deseados incluso con un integrador adaptativo (aunque eso podría ser ineficiente y conducir a imprecisiones). Pero con pasos de tiempo máximo lo suficientemente pequeños, la interpolación lineal y un integrador rápido (Dopri está incorporado) para el segundo sistema significa que estará bien para sistemas "regulares" como este.