Laufkatze mit pendelnder Last - Berechnung mit Runge-Kutta 4. Ordnung
Matlab (einfach)  |   Matlab-Event-Strategie  |   Simulink  |   Runge-Kutta  |   Animation

Aufgabe


Laufkatze mit pendelnder Last

Eine Laufkatze (Masse mK) trägt eine Last (Masse einschließlich Anhängevorrichtung: mL, Massenträgheitsmoment bezüglich des Schwerpunktes S: JL). In der skizzierten Ruhelage beginnt für eine kurze Zeit Δt die konstante Antriebskraft F0 zu wirken, die danach wieder abgeschaltet wird. Nach dem Zurücklegen der Strecke a stößt die Laufkatze auf einen elastischen Puffer (Federzahl c).

Die Bewegung von Laufkatze und Last soll, beginnend aus der Ruhelage, für die ersten 10 Sekunden analysiert werden.

Gegeben:

mK = 100 kg ;  JL = 400 kgm2 ;  lS = 4 m ;  F0 = 2000 N ;
mL = 500 kg ;  c = 200000 N/m ;  Δt = 1 s ;  a = 5 m .

Die Aufgabe wird in den Kapiteln "Prinzipien der Mechanik" und "Verifizieren von Computerrechnungen" behandelt.

Bewegungs-Differenzialgleichungen, Vorbereitung der Matlab-Rechnung

Generalisierte Koordinaten

Die Besonderheit dieser Aufgabe besteht in dem Eintreten von "Ereignissen" (Abschalten der Antriebskraft, Zu- und Abschalten einer Feder). Man erfasst sie, indem an die Stelle der Kraft F0 die zeitabhängige Kraft Ft tritt und die Federkonstante c durch ct ersetzt wird:

Zeitabhängige Antriebskraft, zeitabhängige Federzahl

Unter Verwendung der nebenstehend skizzierten Koordinaten gelten folgende Bewegungs-Differenzialgleichungen (die ausführlich kommentierte Herleitung findet man im Kapitel "Prinzipien der Mechanik"):

Bewegungs-Differenzialgleichungen

Der verwendete Runge-Kutta-Solver 4. Ordnung für die numerische Integration erwartet ein Differenzialgleichungssystem 1. Ordnung. Deshalb werden die beiden neuen Variablen v und ω eingeführt:

Definition von zusätzlichen Variablen

Damit kann das Anfangswertproblem so formuliert werden:

Komplettes Anfangswertproblem

Weil die Differenzialgleichungen für den Runge-Kutta-Solver in Form einer Berechnungsvorschrift für die Ableitungen der gesuchten Funktionen bereitgestellt werden müssen, wurden die beiden in den Beschleunigungsgliedern gekoppelten Gleichungen nach der Cramerschen Regel aufgelöst.

Null-Potenzial

Einer Empfehlung im Kapitel "Verifizieren von Computerrechnungen" folgend, wird eine Energiekurve als Kontrollfunktion zusätzlich berechnet. Die potenzielle Energie soll nur für das bewegte System berücksichtigt werden (während des Kontakts mit der Feder ist auch in dieser potenzielle Energie gespeichert). Im Kapitel "Verifizieren von Computerrechnungen" wird gezeigt, dass mit dem Null-Potenzial entsprechend nebenstehender Skizze und den Anteilen der kinetischen Energie aus der Bewegung von Laufkatze und pendelnder Last folgende Beziehung für die Gesamtenergie des bewegten Systems gilt:

Gesamtenergie des bewegten Systems
Diese Funktion wird mit den ermittelten Werten für x(t), φ(t), v(t) und ω(t) berechnet und graphisch dargestellt.

Matlab-Script

Die für die numerische Integration geschriebene Function rk4.m arbeitet mit den klassischen Runge-Kutta-Formeln 4. Ordnung, wie sie im Kapitel "Kinetik des Massenpunktes" für eine Differenzialgleichung angegeben sind, kann aber ein beliebiges Differenzialgleichungssystem mit n Gleichungen 1. Ordnung lösen. Der Function müssen das Integrationsintervall (Anfangs- und Endzeit), ein Vektor mit den Anfangsbedingungen und die Anzahl der Zeitschritte übergeben werden, in die das Integrationsintervall unterteilt werden soll (der Algorithmus arbeitet mit fester Schrittweite). Außerdem muss die Function benannt werden, die die Differenzialgleichungen beschreibt (im folgenden Script: RechteSeite). Abgeliefert werden der Vektor mit den Zeiten, für die Funktionswerte berechnet wurden, und eine Matrix, in der spaltenweise alle berechneten Funktionswerte (hier also x(t), φ(t), v(t) und ω(t)) enthalten sind:

function LaufkatzeRK4 ()

% Parameter (global definiert, damit Wertaenderung nur an einer Stelle erforderlich):
global mK mL JL c lS Dt F0 a g
mK = 100 ; mL = 500 ; JL = 400 ; c = 200000 ; lS = 4 ; Dt = 1 ; F0 = 2000 ; a = 5 ; g = 9.81 ;

x0    = [0 ; 0 ; 0 ; 0] ;         % Anfangswerte
tspan = [0  10] ;                 % Zeitintervall

% Runge-Kutta 4. Ordnung: ---------------------------------
nrk4 = 200000 ;                   % Anzahl der Runge-Kutta-Schritte
[t xv] = rk4 (@RechteSeite , tspan , x0 , nrk4) ;

% Grafische Ausgabe von x und phi, zunaechst "Sortieren der Ergebnisse":
x     = xv(:,1) ;  % xv ist die Matrix der Ergebnisse,
phi   = xv(:,2) ;  % x, phi ... 
v     = xv(:,3) ;  % v und omega ... 
omega = xv(:,4) ;  % ... sind Vektoren 

Tges  = 0.5*mK*v.^2 + 0.5*mL*(v.^2+lS^2*omega.^2+2*lS*v.*omega.*cos(phi)) ...
       +0.5*JL*omega.^2-mL*g*lS*cos(phi) ;           % Kontrollfunktion "Gesamtenergie"   

subplot(3,1,1) ; plot (t , x)    , grid on , title  ('Bewegung der Laufkatze: x(t)') , axis([0 10 -25 10])
subplot(3,1,2) ; plot (t , phi)  , grid on , title  ('Pendeln der Last: \phi(t)')
subplot(3,1,3) ; plot (t , Tges) , grid on , title  ('Gesamtenergie: T_{ges}(t)')
disp(['Ergebnisse nach ' , num2str(length(t)-1) , ' Zeitschritten:'])  ; % "End"-Kontrolle
disp(['x    (t_end = ' , num2str(t(end)) , ') = ' , num2str(x  (end))])  ; 
disp(['phi  (t_end = ' , num2str(t(end)) , ') = ' , num2str(phi(end))])  ;
disp(['T_ges(t_end = ' , num2str(t(end)) , ') = ' , num2str(Tges(end))])  ;
disp(['(zum Vergleich: T_ges(t = ' , num2str(0) , ') = ' , num2str(Tges(1)) , ')'])  ;

% ============================================================
% Funktion, die die "rechte Seite" des Dgl.-Systems definiert: 
function r = RechteSeite (t , xv)

global mK mL JL c lS Dt F0 a g

x = xv(1) ; phi = xv(2) ; v = xv(3) ; omega = xv(4) ;

if (t < dt) ft = f0 ;  else   ft = 0  ;  end
if (x < a ) ct = 0  ;  else   ct = c  ;  end

a11  = mK+mL ;
a12  = mL*lS*cos(phi) ;
a22  = mL*lS^2+JL ;
b1   = mL*lS*omega^2*sin(phi)-ct*(x-a)+Ft ;
b2   = -mL*g*lS*sin(phi) ;
detA = a11*a22-a12^2 ;

r = [v ; omega ; (b1*a22-b2*a12)/detA ; (b2*a11-b1*a12)/detA] ;

Hinweis: In der Function RechteSeite sind die beiden Zeilen mit den Abfragen, ob die Antriebskraft gerade wirkt und ob gerade Kontakt mit der Feder besteht, farblich hervorgehoben. Diese besonders einfache Realisierung von "Ereignissen" ist hier bei einem Algorithmus, der mit fester Schrittweite arbeitet, unproblemtisch. Diese Aussage steht im Gegensatz zu den Problemen, die bei Algorithmen mit variabler Schrittweite auftreten können. Deshalb wird bei der Verwendung solcher Verfahren (die Matlab-Solver arbeiten so) auf die so genannte "Event"-Strategie verwiesen, die auf der Seite "Laufkatze - Berechnung mit der Event-Strategie" demonstriert wird.

Ergebnisse von 5 Rechnungen

Ergebnisse der Berechnung

Das Matlab-Script gibt die Ergebnisse als graphische Darstellungen und zusätzlich ausgewählte Zahlenwerte in das Command Window aus.

Graphische Darstellung der Ergebnisse

Bei Problemen dieser Art ist auf eine geeignete Schrittweitenwahl zu achten. Hier wurden fünf Rechnungen mit 50, 500, 5000, 50000 und 500000 Schritten durchgeführt. Das ist sicherlich übertrieben, zeigt aber sehr schön, wie sich die Ergebnisse stabilisieren. Die gute Übereinstimmung der Ergebnisse der beiden letzten Rechnungen mit 50000 bzw. 500000 Integrationsschritten zeigt zusätzlich, dass sich die Rundungsfehler bei der gewaltigen Anzahl von Rechenoperationen noch nicht zu einem erkennbaren Fehler kumulieren.

Als Indikatoren können bei jedem beliebigen Anfangswertproblem die berechneten Funktionswerte am Ende des Integrationsintervalls dienen, hier also x(tend) und φ(tend). Bei dieser Rechnung kann zusätzlich der Wert für Tges(tend) verglichen werden. Diese Indikatoren zeigen, dass mit etwa 5000 Schritten ausreichende Genauigkeit erzielt wird.

In der Graphik sieht man, dass die Laufkatze offensichtlich zweimal an die Feder stößt, bevor sie ihren Rückweg antritt und mehrmals (auch ohne äußere Krafteinwirkung) ihre Bewegungsrichtung ändert. Dieses etwas überraschende Verhalten wird hier ausführlich diskutiert.

Die Kurve der Kontrollfunktion Tges(t) liefert ein weiteres Indiz für die Richtigkeit der Rechnung: Startend mit der (negativen) potenziellen Energie, wächst sie infolge der Antriebskraft auf ihren Maximalwert, den sie zum Zeitpunkt t = Δt erreicht. Die beiden "Zacken" in der Kurve kennzeichnen die Energieabgabe an die Feder nach dem Anschlag. Die Energie wird komplett an das bewegte System zurückgegeben, so dass der Rest des Kurvenverlaufs wieder eine horizontale Gerade ist.

Die nachfolgende Abbildung links zeigt einen Zoom in das Bewegungsgesetz der Laufkatze, der den besonders interessanten Teil der Bewegung verdeutlicht. Was im Diagramm noch etwas überraschend erscheint, wird mit der unten rechts zu sehenden Animation der Bewegung verständlich: Man sieht, wie die schwingende Last auf die Laufkatze einwirkt und Änderungen der Bewegungsrichtung auch ohne äußere Krafteinwirkung erzwingt:

 
Bewegungsgesetz der Laufkatze Animation der Bewegung

Die Animation zeigt die Bewegung von Laufkatze und Last etwa für den Zeitbereich, der im links zu sehenden Diagramm als Bewegungsgesetz der Laufkatze dargestellt ist.
Falsche Ergebnisse bei zu großer Schrittweite

Sinn und Notwendigkeit von Kontrollfunktionen


Die Auswirkungen zu großer Schrittweiten bei der numerischen Integration von Anfangswertproblemen zeigt die nebenstehende Graphik. Sie ist das Ergebnis einer Rechnung mit nur 50 Runge-Kutta-Schritten.

Bei den beiden Bewegungsgesetzen für Laufkatze und pendelnde Last würde man keinen Verdacht schöpfen, im Gegenteil: Dass die Laufkatze genau einmal an die Feder anschlägt und dann ihren Rückweg antritt, entspricht eigentlich den Erwartungen.

Aber die Funktion Tges(t) zeigt einen unmöglichen Verlauf: Nachdem sich die Laufkatze nach ihrem Anschlag an die Feder wieder von dieser gelöst hat, ist die Energie des bewegten Systems plötzlich viel größer als vor dem Anschlag. Auch der weitere Verlauf der Kurve, der eine horizontale Gerade sein müsste, zeigt, dass diese Rechnung falsch sein muss.

Download


Das oben zu sehende Matlab-Script steht als LaufkatzeRK4.m zum Download zur Verfügung, ebenso die im dem Script aufgerufene Function "Runge-Kutta 4. Ordnung" als rk4.m.