Ich sehe nichts Falsches an Ihrer Lösung, und tatsächlich bestätigt ein schnelles Matlab-Programm dies (ich habe ode45 mit verwendet$k=1$,$\sigma=1$,$x_{0}=1$Und$v_{0}=0$). Ihr Problem ist, dass Sie zu viel von Ihrer Annäherung erwarten. Es ist in Ordnung, aber nur auf kurzen Zeitskalen.

Es ist möglich, dieses Problem einfach durch Verwendung von Potenzreihen zu lösen. Um die Notation zu vereinfachen, sagen wir$k_t=k*e^{-\frac {t^2}{2\sigma^2}}$. Nehmen Sie dann an, dass die Lösung geschrieben werden kann als:

$$x(t)=\sum_{n=0}^\infty c_n t^n$$

Dann setzt man dies in die gegebene Differentialgleichung ein:

$$r.h.s.:~~\ddot x(t)=\sum_{n=2}^\infty (n)(n-1)c_n t^n\\l.h.s.:~~-k_t\cdot x(t)=-\sum_{n=0}^\infty k_t \cdot c_n t^n=-\sum_{n=2}^\infty k_t \cdot c_{n-2} t^{n-2}$$ Wenn beide gleich sind, erhalten Sie die rekursive Beziehung: $$c_n=\frac {-k_t \cdot c_{n-2}}{(n)(n-1)}$$

Sie erhalten also wie erwartet zwei freie Konstanten,$c_0$Und$c_1$, und Sie können die Reihe in gerade und ungerade Terme teilen. Dadurch erhalten Sie:

$$c_2=\frac {-k_t}{(2)(1)}c_0,~~c_4=\frac {(-k_t)}{(4)(3)}\frac {(-k_t)}{(2)(1)}c_0,... \implies c_{2n}=c_0 \frac {(-k_t)^n}{(2n)!}$$ $$c_3=\frac {(-k_t)}{(3)(2)}c_1,~~c_5=\frac {(-k_t)}{(5)(4)}\frac {(-k_t)}{(3)(2)}c_1,... \implies c_{2n+1}=c_1 \frac {(-k_t)^n}{(2n+1)!}$$

Wenn Sie sowohl gerade als auch ungerade Reihen anordnen, erhalten Sie:

$$x(t)=c_0 \sum_{n=0}^\infty\frac{(-1)^n [k_t^{1/2} \cdot t]^{2n}}{(2n)!}+\frac {c_1}{k_t^{1/2}} \sum_{n=0}^\infty\frac{(-1)^n [k_t^{1/2} \cdot t]^{2n+1}}{(2n+1)!}$$

Die Reihen sind die bekannten Sinus- und Cosinus-Potenzreihenentwicklungen, aber jetzt mit einem anderen Parameter, daher ist das Ergebnis:

$$x(t)=c_0 \cdot cos(\sqrt k *e^{-\frac {t^2}{4\sigma^2}}\cdot t)+\frac {c_1}{\sqrt k *e^{-\frac {t^2}{4\sigma^2}}} \cdot sin(\sqrt k *e^{-\frac {t^2}{4\sigma^2}}\cdot t)$$

Dies ist eine exakte Lösung, keine Annäherung erforderlich, und in diesem Fall, wenn Sie die Grenze nehmen$t \to \infty$entsprechend sollten Sie eine lineare Zeitabhängigkeit erhalten.

Eine Möglichkeit, das Problem anzugehen, besteht darin, eine Reihe von Lösungen zu konstruieren, von denen jede für einen Bereich gültig ist, für den der zeitabhängige Teil des Ausdrucks als konstant angesehen werden kann.

Das heißt, wir konstruieren Lösungen$x_n(t)$die am gültig sind$[t_n, t_{n+1}]$für$\exp(-t_n^2/2\sigma^2) \approx \textrm{const}$. Die Lösungen sind von der Form

$$\begin{aligned} x_n(t) &= a_n\cos(\omega_n t) + b_n\sin(\omega_n t) \\ \dot{x}_n(t) &= -a_n \omega_n\sin(\omega_n t) + b_n\omega_n\cos(\omega_n t) \\ \textrm{with}\;\, \omega_n &= \sqrt{k}\cdot\exp(-t_n^2/2\sigma^2) \end{aligned}$$

Um die Lösungen an den Grenzen zu verbinden$t_n$Wir verwenden Kontinuität von$x(t), \dot{x}(t)$:

$$x_n(t_n) \stackrel{!}{=} x_{n-1}(t_n) \;\;\; \textrm{and} \;\;\; \dot{x}_n(t_n) \stackrel{!}{=} \dot{x}_{n-1}(t_n)$$

Daraus folgt eine Wiederholungsbeziehung für die Koeffizienten$a_n, b_n$für$n \geq 1$:

$$\begin{pmatrix} \cos(\omega_n t_n) & \sin(\omega_n t_n) \\ -\omega_n\sin(\omega_n t_n) & \omega_n\cos(\omega_n t_n) \end{pmatrix} \begin{pmatrix} a_n \\ b_n \end{pmatrix} = \begin{pmatrix} a_{n-1}\cos(\omega_{n-1} t_n) + b_{n-1}\sin(\omega_{n-1} t_n) \\ -a_{n-1}\omega_{n-1}\sin(\omega_{n-1} t_n) + b_{n-1}\omega_{n-1}\cos(\omega_{n-1} t_n) \end{pmatrix}$$

Dieses Gleichungssystem hat eine Determinante$\omega_n \neq 0$und hat daher eine eindeutige Lösung. Für$n = 0$wir haben$a_0 = x_0$Und$b_0 = v_0 / \omega_0$.

Nun müssen noch die Werte für ausgewählt werden$t_n$(mit$t_0 = 0$Fest). Da Voraussetzung war die Zeitabhängigkeit$Q(t) \equiv \exp(-t^2/2\sigma^2)$um auf den entsprechenden Intervallen annähernd konstant zu sein, können wir über die Ableitung eine Schätzung vornehmen$\dot{Q}(t)$:

$$\left\lvert \frac{\dot{Q}(t_n)\cdot (t_{n+1} - t_n)}{Q(t_n)} \right\rvert \leq \epsilon$$

mit gewählter Grenze$\epsilon$. Daraus erhalten wir:

$$t_{n+1} = \left\lvert\frac{Q(t_n)}{\dot{Q}(t_n)}\right\rvert \cdot \epsilon + t_n$$

Dies funktioniert jedoch nur für$\dot{Q}(t) \neq 0$. Falls dies nicht erfüllt ist, können wir stattdessen einfach einen konstanten Aktualisierungswert wählen

$$t_{n+1} = t_n + \delta$$

für einen kleinen Wert$\delta$; Zum Beispiel:

$$\delta = \left\lvert\frac{Q(t_{\textrm{max}})}{\dot{Q}(t_{\textrm{max}})}\right\rvert\cdot\epsilon$$

Wo$t_{\textrm{max}} = arg\,max \lvert\dot{Q}(t)\rvert$.

Beispiel

Verwenden$x_0 = 1\,\textrm{mm}, v_0 = 0, k = 1\,\textrm{s}^{-2}, \sigma = 2\pi\,\textrm{s}$und ein konstantes Update-Schema mit$\delta = 0.001\sigma$wir erhalten:

Code:

import matplotlib.pyplot as plt
from numpy import cos, sin, sqrt, exp, pi
import numpy as np


def xns(x0, v0, k, s, delta=0.001):
    a = x0
    w = sqrt(k)
    b = v0 / w

    def func(t):
        return a*cos(w*t) + b*sin(w*t)

    t = delta * s

    yield t, func

    while True:
        v = w
        w = sqrt(k) * exp(-t**2 / (2 * s**2))
        a, b = np.linalg.solve([
            [cos(w*t), sin(w*t)],
            [-w*sin(w*t), w*cos(w*t)]],

            [a*cos(v*t) + b*sin(v*t),
            -a*v*sin(v*t) + b*v*cos(v*t)]
        )
        t += delta*s
        yield t, func


x0, v0, k, s = 0.001, 0, 1, 2*pi
ts = np.linspace(0, 7*pi*sqrt(k), 1000)
xns = xns(x0, v0, k, s)

xs = []
tn, xn = next(xns)
for t in ts:
    while t >= tn:
        tn, xn = next(xns)
    xs.append(xn(t))
xs = np.asarray(xs)

plt.figure()
plt.title(r'$\rm x_0 = {:.2f}\,[mm],\;'
      r'     v_0 = {:.2f}\,[mm\,s^{{-1}}],\;'
      r'     k   = {:.2f}\,[s^{{-2}}],\;'
      r'\sigma   = {:.2f}\,[s]$'
          .format(x0*1e3, v0*1e3, k, s))
plt.xlabel('t [s]')
plt.ylabel('x [mm]')
plt.plot(ts, xs * 1e3, '-', lw=3)
plt.grid(lw=1.5)
plt.twinx()
plt.ylabel(r'$\rm\sqrt{k}\cdot\exp\left(-t^2/2\sigma^2\right)$', color='#ff7f0e')
plt.tick_params('y', colors='#ff7f0e')
plt.plot(ts, sqrt(k) * exp(-ts**2 / (2 * s**2)), '--', color='#ff7f0e', lw=2)
plt.savefig('example.png', bbox_inches='tight', pad_zeros=0)
plt.show()