Gelöste Aufgaben/GYRO: Unterschied zwischen den Versionen
Keine Bearbeitungszusammenfassung |
|||
(67 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) | |||
Zeile 14: | Zeile 14: | ||
<onlyinclude> | <onlyinclude> | ||
[[Datei:GYRO-01.png|150px|left|mini|Kreisel mit gelenkiger Fußpunktlagerung.]] | [[Datei:GYRO-01.png|150px|left|mini|Kreisel mit gelenkiger Fußpunktlagerung.]] | ||
Gesucht ist die Präzessions-Bahn | Gesucht ist die Präzessions-Bahn eines Kreisels mit [[Sources/Lexikon/Euler-Rotation|Euler-Drehwinklen]]. | ||
Unser Kreisel ist ein Kegel der Höhe ''H'' und Radius ''R''. | Unser Kreisel ist ein Kegel der Höhe ''H'' und Radius ''R''. | ||
Die Bewegungsgleichungen sollen mit dem [[Werkzeuge/Gleichgewichtsbedingungen/Arbeitsprinzipe der Analytischen Mechanik/Prinzip der virtuellen Verrückungen|Prinzip der virtuellen Verrückungen]] aufgestellt werden. Wir suchen nach der Trajektorie des Mittelpunktes des Kreisels für große Kippwinkel. | Die Bewegungsgleichungen sollen mit dem [[Werkzeuge/Gleichgewichtsbedingungen/Arbeitsprinzipe der Analytischen Mechanik/Prinzip der virtuellen Verrückungen|Prinzip der virtuellen Verrückungen]] aufgestellt werden. Wir suchen nach der Trajektorie des Mittelpunktes des Kreisels für große Kippwinkel. | ||
Zeile 24: | Zeile 24: | ||
Maxima brauchen wir zum Aufstellen der Bewegungsgleichungen, die zunächst mal recht komplex aussehen. Dabei nehmen wir die Bewegungsgleichungen wie sie aus den Gleichgewichtsbedingungen kommen und lösen sie als [[Anfangswertprobleme|Anfangswertproblem]]. | Maxima brauchen wir zum Aufstellen der Bewegungsgleichungen, die zunächst mal recht komplex aussehen. Dabei nehmen wir die Bewegungsgleichungen wie sie aus den Gleichgewichtsbedingungen kommen und lösen sie als [[Anfangswertprobleme|Anfangswertproblem]]. | ||
[[Datei:GYRO-02.png|right|Geomertrie des Kreisels]] | [[Datei:GYRO-02.png|120px|right|Geomertrie des Kreisels]] | ||
{{MyCodeBlock|title=Header| | {{MyCodeBlock|title=Header| | ||
text=Wir lösen hier das Anfangswertproblem mit den nichtlinearen Bewegungsgleichungen zu den Koordinaten | text=Wir lösen hier das Anfangswertproblem mit den nichtlinearen Bewegungsgleichungen zu den Koordinaten | ||
::<math>\underline{\varphi} = \left( \begin{array}{c}\varphi_1(t)\\ \varphi_2(t)\\ \varphi_3(t)\end{array}\right)</math>, | ::<math>\underline{\varphi} = \left( \begin{array}{c}\varphi_1(t)\\ \varphi_2(t)\\ \varphi_3(t)\end{array}\right)</math>, | ||
wobei ''φ<sub>1</sub>'', ''φ<sub>2</sub>'' Kippwinkel bezüglich der ''x<sub>1</sub>''- und ''x<sub>2</sub>''-Achsen sind, ''φ<sub>3</sub>'' ist der Rotationswinkel um die Kreisel-Symmetrieachse. | |||
[[Datei:GYRO-03.png|210px|left|Euler-Kippwinkel ''φ<sub>1</sub>'', ''φ<sub>2</sub>'']] | |||
Die Kippwinkel ''φ<sub>1</sub>'', ''φ<sub>2</sub>'' sind im nebenstehenden Bild eingetragen, die aus einer Transformation hervorgehenden Koordinatensysteme erhalten jeweils einen >'< zur Kennzeichnung. Dabei steht am Anfang das blue Koordinatensystem, das durch Kippung um ''φ<sub>2</sub>'' in das grüne und dann durch Kippung um ''φ<sub>1</sub>'' in das rote überführt wird. Nicht dargestellt ist die folgende Drehung um den Rotationwinkel ''φ<sub>3</sub>''. | |||
Die Gleichgewichtsbedingungen kommen aus dem [[Werkzeuge/Gleichgewichtsbedingungen/Arbeitsprinzipe der Analytischen Mechanik/Prinzip der virtuellen Verrückungen|Prinzip der virtuellen Verrückungen]]. | |||
Für diese Gleichungen brauchen wir die virtuelle Arbeit der [[Sources/Lexikon/D'Alembert'sche Trägheitskraft|D'Alembert'schen Trägheitskräfte]] und die virtuelle Arbeit der Gewichtskraft des Kreisels. | Für diese Gleichungen brauchen wir die virtuelle Arbeit der [[Sources/Lexikon/D'Alembert'sche Trägheitskraft|D'Alembert'schen Trägheitskräfte]] und die virtuelle Arbeit der Gewichtskraft des Kreisels. | ||
| | |||
code= | code= | ||
<syntaxhighlight lang="matlab" line start=1> | <syntaxhighlight lang="matlab" line start=1> | ||
Zeile 48: | Zeile 54: | ||
<!--------------------------------------------------------------------------------> | <!--------------------------------------------------------------------------------> | ||
{{MyCodeBlock|title=Declarations | {{MyCodeBlock|title=Declarations | ||
|text=Wir brauchen | |text=Wir brauchen zunächst die Transformationsmatrizen der [[Sources/Lexikon/Euler-Rotation|Euler-Rotation]], also die [[Sources/Lexikon/Drehmatrix|Drehmatrizen]], die unser inertiales Koordinatensystem in das Kreiselfeste Koordinatensystem überführt. Wir kippen zunächst um die ''x<sub>2</sub>''-Achse, dann um die resultierende ''x'<sub>1</sub>''-Achse und schließlich um die Rotationsachse ''x"<sub>3</sub>''. Die Koordinatentransformation ist dann | ||
::<math>\underline{\underline{D}}_{0\to K} = \underline{\underline{D}}_3(\varphi_3(t))\cdot\underline{\underline{D}}_1(\varphi_1(t))\cdot\underline{\underline{D}}_2(\varphi_2(t))</math>. | |||
Und wir führen noch Abkürzungen für die Systemparameter | |||
::<math>{I_y}=\frac{\displaystyle 3 \left( {{R}^{2}}+4 {{H}^{2}}\right) m}{20}, {I_z}=\frac{\displaystyle 3 {{R}^{2}} m}{10}, m=\frac{\displaystyle {\pi} H {{R}^{2}} \rho }{3}</math> | |||
und die Zustandsgrößen | |||
::<math>\frac{d}{d t} {{\varphi }_i}(t)={{\omega }_i}(t)</math> | |||
ein. | |||
|code= | |code= | ||
<syntaxhighlight lang="lisp" line start=1> | <syntaxhighlight lang="lisp" line start=1> | ||
1+1 | /* Euler-Drehmatrizen */ | ||
D[1](φ) := matrix([1,0,0],[0,cos(φ),-sin(φ)],[0,sin(φ),cos(φ)]); | |||
D[2](φ) := matrix([cos(φ),0,sin(φ)],[0,1,0],[-sin(φ),0,cos(φ)]); | |||
D[3](φ) := matrix([cos(φ),-sin(φ),0],[sin(φ),cos(φ),0],[0,0,1]); | |||
coord: [[ φ[1](t), φ[2](t), φ[3](t)], | |||
[δφ[1] ,δφ[2] ,δφ[3] ]]; | |||
q: funmake('matrix,makelist([coord[1][i]],i,1,3)); | |||
abbr: makelist(diff(φ[i](t),t)=ω[i](t),i,1,3); | |||
params: [ | |||
I[y] = m * 3/20*( R^2+4*H^2), | |||
I[z] = m * 3/10* R^2, | |||
m = ρ*%pi*R^2*H/3 ]; | |||
params: append(subst(params[3], [params[1], params[2]]),[params[3]]); | |||
params: [params, makelist(solve(params[i], [H^3,R^4,R^2][i])[1],i,1,3)]; | |||
</syntaxhighlight> | </syntaxhighlight> | ||
}} | }} | ||
{{MyCodeBlock|title=Equations of Motion | {{MyCodeBlock|title=Equations of Motion | ||
|text= | |text=Die Gleichgewichtsbedingungen für den starren Kreisel (die virtuelle Formänderungenergie <math>\delta\Pi</math> ist Null) kommen aus | ||
::<math>\begin{array}{lll}\delta W &=&\displaystyle \sum_i (\vec{F}_i\cdot\delta r_i ) - \rho \int_V \ddot{\vec{r}}_P\cdot \delta\vec{r}_P dV\\ | |||
&\stackrel{!}{=}& 0 \end{array}</math>, | |||
wobei wir nur eine Kraft ''F'' - die Gewichtskraft <math>m g (-\vec{e}_3)</math> - haben und ''V'' das Kreisel-Volumen ist. | |||
Mit dem Ortsvektor zu einem Punkt des Kreisels | |||
::<math>\vec{r}_P = \left(r \;\; 0 \;\; z\right)\cdot \underline{\underline{D}}_3(\alpha)\cdot \underline{\underline{D}}_{0\to K}(\varphi_1, \varphi_2, \varphi_3)\cdot \left(\begin{array}{c}\vec{e}_1\\\vec{e}_2\\\vec{e}_3\end{array}\right) </math> | |||
können wir nun die virtuelle Gesamtarbeit des Systems ausrechnen. Die Parameter mit ''R'' und ''H'' ersetzen wir durch die oben definierten Abkürzungen und erhalten die gekoppelten Bewegungsgleichungen | |||
::<math> | |||
\begin{pmatrix}{I_y} & 0 & 0\\ | |||
0 & \left( 1-{{\cos{\left( {{\varphi }_1}\right) }}^{2}}\right) {I_z}+{{\cos{\left( {{\varphi }_1}\right) }}^{2}} {I_y} & -\sin{\left( {{\varphi }_1}\right) } {I_z}\\ | |||
0 & -\sin{\left( {{\varphi }_1}\right) } {I_z} & {I_z}\end{pmatrix} | |||
\cdot | |||
\ddot{\underline{\varphi}} + | |||
\begin{pmatrix}\left( {{{{\omega }_2}}^{2}} \cos{\left( {{\varphi }_1}\right) } \sin{\left( {{\varphi }_1}\right) }-{{\omega }_2} {{\omega }_3} \cos{\left( {{\varphi }_1}\right) }\right) {I_z}-{{{{\omega }_2}}^{2}} \cos{\left( {{\varphi }_1}\right) } \sin{\left( {{\varphi }_1}\right) } {I_y}\\ | |||
\left( {{\omega }_1} {{\omega }_3} \cos{\left( {{\varphi }_1}\right) }-2 {{\omega }_1} {{\omega }_2} \cos{\left( {{\varphi }_1}\right) } \sin{\left( {{\varphi }_1}\right) }\right) {I_z}+2 {{\omega }_1} {{\omega }_2} \cos{\left( {{\varphi }_1}\right) } \sin{\left( {{\varphi }_1}\right) } {I_y}\\ | |||
{{\omega }_1} {{\omega }_2} \cos{\left( {{\varphi }_1}\right) } {I_z}\end{pmatrix} | |||
= | |||
\frac{\displaystyle 3}{\displaystyle 4} H m g\begin{pmatrix} | |||
\sin{\left( {{\varphi }_1}\right) } \cos{\left( {{\varphi }_2}\right) }\\ | |||
\cos{\left( {{\varphi }_1}\right) } \sin{\left( {{\varphi }_2}\right) }\\ | |||
0\end{pmatrix} | |||
</math> | |||
Dieses System von gewöhnlichen Differentialgleichung müssen wir nach den Winkelbeschleunigungen lösen - und das geht nur, wenn die Massenmatrix regulär ist. Wir prüfen das anhand der Systemdeterminante | |||
::<math> | |||
\det{\underline{\underline{M}}} = \cos(\phi_1)^2\;I_y^2\;I_z | |||
</math> | |||
Für den Kippwinkel muss also ''cos(φ<sub>1</sub>)≠0'' oder ''0 < φ<sub>1</sub> < 90°'' gelten. Das können wir für unsere Problemstellung gut einhalten. | |||
|code= | |code= | ||
<syntaxhighlight lang="lisp" line start=1> | <syntaxhighlight lang="lisp" line start=1> | ||
1+1 | /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ | ||
/* local vector to some material point with coordinates φ[i](t), i=1,2,3 */ | |||
/* trafo, order of rotations: y, x', z'' */ | |||
r[p] : matrix([r,0,z]).D[3](α).D[3](φ[3](t)).D[1](φ[1](t)).D[2](φ[2](t)); | |||
/* variation of local vector */ | |||
δr[p] : sum(subst([ε=0],diff(subst([coord[1][i]=coord[1][i]+ε*coord[2][i]],r[p]),ε)),i,1,3); | |||
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ | |||
/* virtual work of d'Alembert forces */ | |||
δW[a] :-ρ*diff(r[p],t,2).δr[p]$ | |||
/* integrate over body */ | |||
δW[a] : integrate(integrate(integrate(r*δW[a], α,0,2*%pi), r,0,R*(z/H)), z,0,H)$ | |||
δW[a] : expand(expand(expand(expand(expand(expand(expand(δW[a])))))))$ | |||
δW[a] : expand(subst(params[2],δW[a])); | |||
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ | |||
/* virtual work of external (gravitational) force */ | |||
r[m] : subst([r=0, z=3*H/4], r[p]); | |||
δr[m] : sum(subst([ε=0],diff(subst([coord[1][i]=coord[1][i]+ε*coord[2][i]],r[m]),ε)),i,1,3); | |||
δW[g] : m*matrix([0,0,-g]).δr[m]; | |||
δW[g] : expand(δW[g]); | |||
</syntaxhighlight> | </syntaxhighlight> | ||
}} | }} | ||
{{MyCodeBlock|title=Solving | {{MyCodeBlock|title=Solving | ||
|text= | |text=Mit der Spaltenmatrix der Zustandsgrößen | ||
::<math>\underline{q}(t) = \left(\begin{array}{c}\varphi_1(t)\\ | |||
\varphi_2(t)\\ | |||
\varphi_3(t)\\ | |||
\omega_1(t)\\ | |||
\omega_2(t)\\ | |||
\omega_3(t)\\ | |||
\end{array}\right)</math> | |||
lösen wir die gewöhnlichen Differentialgleichungen | |||
::<math>\underline{\dot{q}}(t) = \underline{f}(\underline{q}(t))</math> | |||
Dazu formulieren wir die Bewegungsgleichungen zunächst in Maxima und übertragen sie dann in ein Matlab<sup>©</sup>-Script. Die Bewegungsgleichungen machen wir mit der Zeit | |||
::<math>T=\sqrt{\frac{\displaystyle 3 H m g}{4 I_y}}</math> | |||
dimensionslos (die Winkel selbst sind ja bereits dimensionslos). Die dimensionslose Zeit <math>\tau = t/T</math>. | |||
|code= | |code= | ||
<syntaxhighlight lang="lisp" line start=1> | <syntaxhighlight lang="lisp" line start=1> | ||
1 | /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ | ||
/* equations of motion */ | |||
eom: makelist(coeff(-δW[a],coord[2][row]),row,1,3); | |||
/* mass matrix */ | |||
M: makelist(makelist(coeff(eom[row],diff(coord[1][col],t,2)),col,1,3),row,1,3); | |||
M: trigsimp(funmake('matrix,M)); | |||
/* M^(-1) */ | |||
Mi : trigsimp(invert(M)); | |||
/* the rest ... */ | |||
gyr: trigsimp(expand(eom - M.diff(q,t,2))); | |||
P: makelist(coeff(-δW[g],coord[2][row]),row,1,3); | |||
</syntaxhighlight> | </syntaxhighlight> | ||
}} | }} | ||
{{ | {{MyZipfileBlock | ||
|text= | |title=Matlab<sup>©</sup>-files | ||
|text =[[Datei:GYRO-folder-structure.png|links|mini|Folder Structure]]Die Datei-Struktur zeit das Skript <nowiki>GYRO.m</nowiki>. Classes und Functions sind in den jeweiligen Ordnern. Die Excel-Datei hält alle System-Parameter. | |||
Den komplette Quellcode zu diesem Programm können Sie über dieses ZIP-File rechts herunterladen. | |||
|file =GYRO.zip}} | |||
{{MyCodeBlock|title=Postprocessing | |||
|text=Die Ergebnisse der numerischen Integration tragen wir für die Winkel ''φ<sub>1</sub>(t)'', ''φ<sub>2</sub>(t)'' sowie für die Winkelgeschwindigkeiten ''ω<sub>1</sub>(t)'', ''ω<sub>2</sub>(t)'' auf. | |||
Es folgen noch die Trajektorie des Mittellinien-Endpunkts des Kreisels und die Phasendiagramme. | |||
<table class="wikitable" style="background-color:white; float: left; margin-right:14px;"> | |||
<tr><td>[[Datei:GYRO-11.png|300px|right|Winkel]]</td><td>[[Datei:GYRO-12.png|300px|right|Winkelgeschwindigkeit]]</td></tr> | |||
<tr><td>[[Datei:GYRO-13.png|300px|right|Trajektorie]]</td><td>[[Datei:GYRO-14.png|300px|right|Phasendiagramme]]</td></tr> | |||
</table> | |||
|code= | |code= | ||
<syntaxhighlight lang="lisp" line start=1> | <syntaxhighlight lang="lisp" line start=1> | ||
1+1 | /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ | ||
/* if you wanted to linearize w.r.t. φ[1], φ[2] and ω[1], ω[2] */ | |||
gyrs: trigsimp(subst(abbr,gyr)); | |||
smalls: [ω[1](t)=ε*ω[1](t),ω[2](t)=ε*ω[2](t)]; | |||
gyrs: subst([ε^2=0,ε=1],expand(subst(smalls,gyrs))); | |||
G: makelist(makelist(coeff(expand(gyrs[row][1]/ω[3](t)),ω[col](t)),col,1,3),row,1,3); | |||
G: trigsimp(funmake('matrix,G)); | |||
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ | |||
/* prepare output for Matlab */ | |||
toNumerics: append(makelist(sin(φ[i](t))=s[i],i,1,3),makelist(cos(φ[i](t))=c[i],i,1,3), [I[z]=i*I[y]], solve(3/4*H*m*g=j*I[y],H)); | |||
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ | |||
MiG: ratsimp(subst(abbr,subst(toNumerics,trigsimp(Mi.gyr)))); | |||
MiP: ratsimp(subst(abbr,subst(toNumerics,trigsimp(Mi.P)))); | |||
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ | |||
rhs1: -MiG; | |||
/* | |||
[-c(1)*i*omega(2)*omega(3)-(c(1)*s(1)-c(1)*s(1)*i)*omega(2)^2; | |||
(i*omega(1)*omega(3)+(2*s(1)-s(1)*i)*omega(1)*omega(2))/c(1); | |||
(s(1)*i*omega(1)*omega(3)+(-s(1)^2*i+s(1)^2+1)*omega(1)*omega(2))/c(1)]; | |||
*/ | |||
rhs2: -MiP; | |||
/* | |||
s(1)*c(2)*obj.j | |||
(s(2)*obj.j)/c(1) | |||
(s(1)*s(2)*obj.j)/c(1)) | |||
*/ | |||
/* Center-Line*/ | |||
r[c]: subst(toNumerics,subst([r=0, z=1],r[p])); | |||
/* | |||
[c[1]*s[2]; | |||
-s[1]; | |||
c[1]*c[2]]; | |||
*/ | |||
</syntaxhighlight> | </syntaxhighlight> | ||
}} | }} | ||
{{MyCodeBlock|title=Nachtrag | |||
|text=Meist linearisiert man die Bewegungsgleichungen, indem man von kleinen Kippwinkeln ausgeht (''φ<sub>1</sub><<1'', ''φ<sub>2</sub><<1''). Für den Kreisel gilt ''ω<sub>1</sub><<ω<sub>3</sub>'', ''ω<sub>2</sub><<ω<sub>3</sub>'', so dass man außerdem ''ω<sub>3</sub> = constant'' setzten darf. | |||
Damit erhalten wir die "übliche" vereinfachte Bewegungsgleichung | |||
::<math> | |||
\begin{pmatrix}{I_y} & 0 & 0\\ | |||
0 & {I_y} & 0\\ | |||
</ | 0 & 0 & {I_z}\end{pmatrix}\cdot \ddot{\underline{\varphi}} | ||
+ | |||
\omega_3\cdot \begin{pmatrix}0 & -I_z& 0\\ | |||
I_z& 0 & 0\\ | |||
0 & 0 & 0\end{pmatrix}\cdot \dot{\underline{\varphi}} | |||
= | |||
\frac{\displaystyle 3}{\displaystyle 4} H m g \begin{pmatrix}1&0&0\\0&1&0\\0&0&0\end{pmatrix}\cdot \underline{\varphi} | |||
</math> | |||
|code= | |||
<syntaxhighlight lang="lisp" line start=1> | |||
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ | |||
/* simplify */ | |||
MS: subst([cos(φ[1](t))=1, sin(φ[1](t))=0], M); | |||
gyrS: subst([ε^2=0, ε=1],expand(subst([cos(φ[1](t))=1, sin(φ[1](t))=φ[1](t), ω[1](t)=ε*ω[1](t), ω[2](t)=ε*ω[2](t)],subst(abbr,gyr)))); | |||
PS: subst([cos(φ[1](t))=1, cos(φ[2](t))=1, sin(φ[1](t))=φ[1](t), sin(φ[2](t))=φ[2](t)], P); | |||
</syntaxhighlight> | |||
}} | |||
Dieses lineare System von gewöhnlichen Bewegungsgleichungen kann man dann hervorragend als Eigenwertproblem analysieren. | |||
<hr/> | |||
'''Links''' | '''Links''' | ||
* ... | * ... |
Aktuelle Version vom 27. Oktober 2023, 12:10 Uhr
Aufgabenstellung
Kreisel und Ihre Bewegungsgleichungen sind immer wieder eine Herausforderung für uns Ingenieure. Hier nähern wir uns hier dem Thema mit dem Aufstellen und Lösen der Bewegungsgleichungen für große Winkel - und damit nichtlinearen Differentialgleichungen. Die sonst üblichen Linearisierungen führen wir nicht durch - und schauen, ob wir die Gleichungen noch gelöst bekommen.
Gesucht ist die Präzessions-Bahn eines Kreisels mit Euler-Drehwinklen. Unser Kreisel ist ein Kegel der Höhe H und Radius R. Die Bewegungsgleichungen sollen mit dem Prinzip der virtuellen Verrückungen aufgestellt werden. Wir suchen nach der Trajektorie des Mittelpunktes des Kreisels für große Kippwinkel.
Lösung mit Maxima und Matlab®
Wir arbeiten mit Maxima und Matlab.
Maxima brauchen wir zum Aufstellen der Bewegungsgleichungen, die zunächst mal recht komplex aussehen. Dabei nehmen wir die Bewegungsgleichungen wie sie aus den Gleichgewichtsbedingungen kommen und lösen sie als Anfangswertproblem.
Header
Wir lösen hier das Anfangswertproblem mit den nichtlinearen Bewegungsgleichungen zu den Koordinaten
- ,
wobei φ1, φ2 Kippwinkel bezüglich der x1- und x2-Achsen sind, φ3 ist der Rotationswinkel um die Kreisel-Symmetrieachse.
Die Kippwinkel φ1, φ2 sind im nebenstehenden Bild eingetragen, die aus einer Transformation hervorgehenden Koordinatensysteme erhalten jeweils einen >'< zur Kennzeichnung. Dabei steht am Anfang das blue Koordinatensystem, das durch Kippung um φ2 in das grüne und dann durch Kippung um φ1 in das rote überführt wird. Nicht dargestellt ist die folgende Drehung um den Rotationwinkel φ3.
Die Gleichgewichtsbedingungen kommen aus dem Prinzip der virtuellen Verrückungen. Für diese Gleichungen brauchen wir die virtuelle Arbeit der D'Alembert'schen Trägheitskräfte und die virtuelle Arbeit der Gewichtskraft des Kreisels.
/*******************************************************/
/* MAXIMA script */
/* version: wxMaxima 21.05.2 */
/* author: Andreas Baumgart */
/* last updated: 2022-03-27 */
/* ref: gyroscopic precession */
/* description: solve using principle of virt. work */
/*******************************************************/
Declarations
Wir brauchen zunächst die Transformationsmatrizen der Euler-Rotation, also die Drehmatrizen, die unser inertiales Koordinatensystem in das Kreiselfeste Koordinatensystem überführt. Wir kippen zunächst um die x2-Achse, dann um die resultierende x'1-Achse und schließlich um die Rotationsachse x"3. Die Koordinatentransformation ist dann
- .
Und wir führen noch Abkürzungen für die Systemparameter
und die Zustandsgrößen
ein.
/* Euler-Drehmatrizen */
D[1](φ) := matrix([1,0,0],[0,cos(φ),-sin(φ)],[0,sin(φ),cos(φ)]);
D[2](φ) := matrix([cos(φ),0,sin(φ)],[0,1,0],[-sin(φ),0,cos(φ)]);
D[3](φ) := matrix([cos(φ),-sin(φ),0],[sin(φ),cos(φ),0],[0,0,1]);
coord: [[ φ[1](t), φ[2](t), φ[3](t)],
[δφ[1] ,δφ[2] ,δφ[3] ]];
q: funmake('matrix,makelist([coord[1][i]],i,1,3));
abbr: makelist(diff(φ[i](t),t)=ω[i](t),i,1,3);
params: [
I[y] = m * 3/20*( R^2+4*H^2),
I[z] = m * 3/10* R^2,
m = ρ*%pi*R^2*H/3 ];
params: append(subst(params[3], [params[1], params[2]]),[params[3]]);
params: [params, makelist(solve(params[i], [H^3,R^4,R^2][i])[1],i,1,3)];
Equations of Motion
Die Gleichgewichtsbedingungen für den starren Kreisel (die virtuelle Formänderungenergie ist Null) kommen aus
- ,
wobei wir nur eine Kraft F - die Gewichtskraft - haben und V das Kreisel-Volumen ist.
Mit dem Ortsvektor zu einem Punkt des Kreisels
können wir nun die virtuelle Gesamtarbeit des Systems ausrechnen. Die Parameter mit R und H ersetzen wir durch die oben definierten Abkürzungen und erhalten die gekoppelten Bewegungsgleichungen
Dieses System von gewöhnlichen Differentialgleichung müssen wir nach den Winkelbeschleunigungen lösen - und das geht nur, wenn die Massenmatrix regulär ist. Wir prüfen das anhand der Systemdeterminante
Für den Kippwinkel muss also cos(φ1)≠0 oder 0 < φ1 < 90° gelten. Das können wir für unsere Problemstellung gut einhalten.
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* local vector to some material point with coordinates φ[i](t), i=1,2,3 */
/* trafo, order of rotations: y, x', z'' */
r[p] : matrix([r,0,z]).D[3](α).D[3](φ[3](t)).D[1](φ[1](t)).D[2](φ[2](t));
/* variation of local vector */
δr[p] : sum(subst([ε=0],diff(subst([coord[1][i]=coord[1][i]+ε*coord[2][i]],r[p]),ε)),i,1,3);
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* virtual work of d'Alembert forces */
δW[a] :-ρ*diff(r[p],t,2).δr[p]$
/* integrate over body */
δW[a] : integrate(integrate(integrate(r*δW[a], α,0,2*%pi), r,0,R*(z/H)), z,0,H)$
δW[a] : expand(expand(expand(expand(expand(expand(expand(δW[a])))))))$
δW[a] : expand(subst(params[2],δW[a]));
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* virtual work of external (gravitational) force */
r[m] : subst([r=0, z=3*H/4], r[p]);
δr[m] : sum(subst([ε=0],diff(subst([coord[1][i]=coord[1][i]+ε*coord[2][i]],r[m]),ε)),i,1,3);
δW[g] : m*matrix([0,0,-g]).δr[m];
δW[g] : expand(δW[g]);
Solving
Mit der Spaltenmatrix der Zustandsgrößen
lösen wir die gewöhnlichen Differentialgleichungen
Dazu formulieren wir die Bewegungsgleichungen zunächst in Maxima und übertragen sie dann in ein Matlab©-Script. Die Bewegungsgleichungen machen wir mit der Zeit
dimensionslos (die Winkel selbst sind ja bereits dimensionslos). Die dimensionslose Zeit .
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* equations of motion */
eom: makelist(coeff(-δW[a],coord[2][row]),row,1,3);
/* mass matrix */
M: makelist(makelist(coeff(eom[row],diff(coord[1][col],t,2)),col,1,3),row,1,3);
M: trigsimp(funmake('matrix,M));
/* M^(-1) */
Mi : trigsimp(invert(M));
/* the rest ... */
gyr: trigsimp(expand(eom - M.diff(q,t,2)));
P: makelist(coeff(-δW[g],coord[2][row]),row,1,3);
Matlab©-files
Die Datei-Struktur zeit das Skript GYRO.m. Classes und Functions sind in den jeweiligen Ordnern. Die Excel-Datei hält alle System-Parameter.
Den komplette Quellcode zu diesem Programm können Sie über dieses ZIP-File rechts herunterladen.
download compressed archive →
Postprocessing
Die Ergebnisse der numerischen Integration tragen wir für die Winkel φ1(t), φ2(t) sowie für die Winkelgeschwindigkeiten ω1(t), ω2(t) auf. Es folgen noch die Trajektorie des Mittellinien-Endpunkts des Kreisels und die Phasendiagramme.
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* if you wanted to linearize w.r.t. φ[1], φ[2] and ω[1], ω[2] */
gyrs: trigsimp(subst(abbr,gyr));
smalls: [ω[1](t)=ε*ω[1](t),ω[2](t)=ε*ω[2](t)];
gyrs: subst([ε^2=0,ε=1],expand(subst(smalls,gyrs)));
G: makelist(makelist(coeff(expand(gyrs[row][1]/ω[3](t)),ω[col](t)),col,1,3),row,1,3);
G: trigsimp(funmake('matrix,G));
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* prepare output for Matlab */
toNumerics: append(makelist(sin(φ[i](t))=s[i],i,1,3),makelist(cos(φ[i](t))=c[i],i,1,3), [I[z]=i*I[y]], solve(3/4*H*m*g=j*I[y],H));
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
MiG: ratsimp(subst(abbr,subst(toNumerics,trigsimp(Mi.gyr))));
MiP: ratsimp(subst(abbr,subst(toNumerics,trigsimp(Mi.P))));
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
rhs1: -MiG;
/*
[-c(1)*i*omega(2)*omega(3)-(c(1)*s(1)-c(1)*s(1)*i)*omega(2)^2;
(i*omega(1)*omega(3)+(2*s(1)-s(1)*i)*omega(1)*omega(2))/c(1);
(s(1)*i*omega(1)*omega(3)+(-s(1)^2*i+s(1)^2+1)*omega(1)*omega(2))/c(1)];
*/
rhs2: -MiP;
/*
s(1)*c(2)*obj.j
(s(2)*obj.j)/c(1)
(s(1)*s(2)*obj.j)/c(1))
*/
/* Center-Line*/
r[c]: subst(toNumerics,subst([r=0, z=1],r[p]));
/*
[c[1]*s[2];
-s[1];
c[1]*c[2]];
*/
Nachtrag
Meist linearisiert man die Bewegungsgleichungen, indem man von kleinen Kippwinkeln ausgeht (φ1<<1, φ2<<1). Für den Kreisel gilt ω1<<ω3, ω2<<ω3, so dass man außerdem ω3 = constant setzten darf. Damit erhalten wir die "übliche" vereinfachte Bewegungsgleichung
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* simplify */
MS: subst([cos(φ[1](t))=1, sin(φ[1](t))=0], M);
gyrS: subst([ε^2=0, ε=1],expand(subst([cos(φ[1](t))=1, sin(φ[1](t))=φ[1](t), ω[1](t)=ε*ω[1](t), ω[2](t)=ε*ω[2](t)],subst(abbr,gyr))));
PS: subst([cos(φ[1](t))=1, cos(φ[2](t))=1, sin(φ[1](t))=φ[1](t), sin(φ[2](t))=φ[2](t)], P);
Dieses lineare System von gewöhnlichen Bewegungsgleichungen kann man dann hervorragend als Eigenwertproblem analysieren.
Links
- ...
Literature
- ...