Relativistische Beschleunigung

[Yukterez]

Das ist die deutschsprachige Version.   An english version is available on en.yukterez.net


Inhalt: konstante Kraft | konstante Koordinatenbeschleunigung | konstante Leistung, Diskussion: hier entlang

[Yukterez]

KONSTANTE KRAFT

 

Die Geschwindigkeit v ergibt sich über den Gammafaktor γ



mit dem relativistischen Impuls p



wobei Kraft F, Ruhemasse m und Eigenbeschleunigung a über



mit dem Differential von Impuls p über Koordinatenzeit t verknüpft sind. Damit ergibt sich mit F=konstant



Plot mit der Koordinatenzeit t als x-Achse (SI-Einheiten, Impuls und Energie als spezifische Größen pro kg Ruhemasse):



Analytische Lösungen für Eigenzeit τ und Strecke x:

Code:

Code: Alles auswählen

(* Eigenbeschleunigung, Methode 1 *)

a=1000000m/sek^2;                                              (* Beschleunigung *)
v0=0m/sek;                                             (* Anfangsgeschwindigkeit *)

c=3*^8m/sek;                                             (* Lichtgeschwindigkeit *)
m=sek=1;                                                            (* Einheiten *)

γ[v_]:=1/Sqrt[1-v^2/c^2]; γ0=γ[v0];                                     (* Gamma *)
v[t_]:=(a t+v0 γ0)/Sqrt[1+(a t+v0 γ0)^2/c^2];                 (* Geschwindigkeit *)
e[t_]:=c^2 γ[v[t]]-c^2;                        (* spezifische kinetische Energie *)
p[t_]:=v[t]γ[v[t]];                                       (* spezifischer Impuls *)

sol=NDSolve[{τ'[t]==Sqrt[1-v[t]^2/c^2], τ[0]==0, X'[t]==v[t], X[0]==0},
{τ, X}, {t, 0, 1000}, Method->{"ImplicitRungeKutta", "DifferenceOrder"->20},
MaxSteps->Infinity, InterpolationOrder->All, WorkingPrecision->32];

т[t_]:=Evaluate[τ[t]/.sol][[1]];                                    (* Eigenzeit *)
ť[t_]:=т'[t]; ṫ[t_]:=1/ ť[t];                                  (* Zeitdilatation *)
α[t_]:=Evaluate[X''[t]/.sol][[1]];                  (* Koordinatenbeschleunigung *)
A[t_]:=α[t] γ[v[t]]^3;                                    (* Eigenbeschleunigung *)
x[t_]:=Evaluate[X[t]/.sol][[1]];                                     (* Position *)

plot[f_]:=Plot[f[t], {t, 0, 1000}, Frame->True, ImagePadding->{{50, 8}, {16, 8}},
ImageSize->320, PlotRange->All, PlotStyle->Thick, AspectRatio->1/2]

Grid[{{plot[т], plot[ť]},
{"      Eigenzeit τ", "      Zeitdilatation dτ/dt"},
{}, {plot[v], plot[p]},
{"      Geschwindigkeit v", "      Impuls p"},
{}, {plot[x], plot[e]},
{"      Strecke x", "      kinetische Energie"},
{}, {plot[A], plot[α]},
{"      Eigenbeschleunigung a", "      Koordinatenbeschleunigung α"}},
Alignment->Center]

Code: Alles auswählen

(* Eigenbeschleunigung, Methode 2 *)

a=1000000m/sek^2;                                              (* Beschleunigung *)
v0=0m/sek;                                             (* Anfangsgeschwindigkeit *)

c=3*^8m/sek;                                             (* Lichtgeschwindigkeit *)
m=sek=1;                                                            (* Einheiten *)

γ[v_]:=1/Sqrt[1-v^2/c^2]; γ0=γ[v0];                                     (* Gamma *)
e[t_]:=c^2 γ[v[t]]-c^2;                        (* spezifische kinetische Energie *)
p[t_]:=v[t] γ[v[t]];                                      (* spezifischer Impuls *)

sol=NDSolve[{τ'[t]==Sqrt[1-V[t]^2/c^2], τ[0]==0,
(V[t]^2 V'[t])/(c^2 (1-V[t]^2/c^2)^(3/2))+V'[t]/Sqrt[1-V[t]^2/c^2]==a, V[0]==v0,
X'[t]==V[t], X[0]==0}, {τ, V, X}, {t, 0, 1000},
Method->{"ImplicitRungeKutta", "DifferenceOrder"->20}, MaxSteps->Infinity,
InterpolationOrder->All, WorkingPrecision->32];

т[t_]:=Evaluate[τ[t]/.sol][[1]];                                    (* Eigenzeit *)
v[t_]:=Evaluate[V[t]/.sol][[1]];                              (* Geschwindigkeit *)
ť[t_]:=т'[t]; ṫ[t_]:=1/ť[t]                                    (* Zeitdilatation *)
α[t_]:=Evaluate[X''[t]/.sol][[1]];                  (* Koordinatenbeschleunigung *)
A[t_]:=α[t]γ[v[t]]^3;                                     (* Eigenbeschleunigung *)
x[t_]:=Evaluate[X[t]/.sol][[1]];                                     (* Position *)

plot[f_]:=Plot[f[t], {t, 0, 1000}, Frame->True, ImagePadding->{{50, 8}, {16, 8}},
ImageSize->320, PlotRange->All, PlotStyle->Thick, AspectRatio->1/2]

Grid[{{plot[т], plot[ť]},
{"      Eigenzeit τ", "      Zeitdilatation dτ/dt"},
{}, {plot[v], plot[p]},
{"      Geschwindigkeit v", "      Impuls p"},
{}, {plot[x], plot[e]},
{"      Strecke x", "      kinetische Energie"},
{}, {plot[A], plot[α]},
{"      Eigenbeschleunigung a", "      Koordinatenbeschleunigung α"}},
Alignment->Center]

Code: Alles auswählen

(* Eigenbeschleunigung, Methode 3 *)

a=1000000m/sek^2;                                              (* Beschleunigung *)
v0=0m/sek;                                             (* Anfangsgeschwindigkeit *)

c=3*^8m/sek;                                             (* Lichtgeschwindigkeit *)
m=sek=1;                                                            (* Einheiten *)

γ[v_]:=1/Sqrt[1-v^2/c^2]; γ0=γ[v0];                                     (* Gamma *)
e[t_]:=c^2 γ[v[t]]-c^2;                        (* spezifische kinetische Energie *)
p[t_]:=v[t] γ[v[t]];                                      (* spezifischer Impuls *)
sol=NDSolve[{T'[τ]==1/Sqrt[1-V[τ]^2/c^2], T[0]==0, V'[τ]==a(1-V[τ]^2/c^2),
V[0]==v0, X'[τ]==V[τ]/Sqrt[1-V[τ]^2/c^2], X[0]==0}, {V, T, X}, {τ, 0, 1000},
Method->{"ImplicitRungeKutta", "DifferenceOrder"->20}, MaxSteps->Infinity,
InterpolationOrder->All, WorkingPrecision->32];

t[τ_]:=Evaluate[T[τ]/.sol][[1]];                              (* Koordinatenzeit *)
т=Interpolation[Table[{t[j], j}, {j, 0, 1000}]];                    (* Eigenzeit *)
v[t_]:=Evaluate[V[т[t]]/.sol];                                (* Geschwindigkeit *)
ṫ[t_]:=Evaluate[T'[т[t]]/.sol]; ť[t_]:=1/ṫ[t];                 (* Zeitdilatation *)
α[t_]:=x''[t];                                      (* Koordinatenbeschleunigung *)
A[t_]:=α[t]γ[v[t]]^3;                                     (* Eigenbeschleunigung *)
x[t_]:=Evaluate[X[т[t]]/.sol];                                       (* Position *)

plot[f_]:=Plot[f[t], {t, 0, 1000}, Frame->True, ImagePadding->{{50, 8}, {16, 8}},
ImageSize->320, PlotRange->All, PlotStyle->Thick, AspectRatio->1/2]

Grid[{{plot[т], plot[ť]},
{"      Eigenzeit τ", "      Zeitdilatation dτ/dt"},
{}, {plot[v], plot[p]},
{"      Geschwindigkeit v", "      Impuls p"},
{}, {plot[x], plot[e]},
{"      Strecke x", "      kinetische Energie"},
{}, {plot[A], plot[α]},
{"      Eigenbeschleunigung a", "      Koordinatenbeschleunigung α"}},
Alignment->Center]

3 verschiedene Methoden um ans Ziel zu kommen: hier entlang

[Yukterez]

KONSTANTE KOORDINATENBESCHLEUNIGUNG

 

Mit α=dv/dt=d²x/dt²=a/γ³=konstant ist die Formel für die Geschwindigkeit v ganz einfach



Die Lichtgeschwindigkeit wäre bei konstanter Koordinatenbeschleunigung erreicht wenn



Plot mit der Koordinatenzeit t als x-Achse (SI-Einheiten, Impuls und Energie als spezifische Größen pro kg Ruhemasse):



Analytische Lösungen für Eigenzeit τ und Strecke x:

Code:

Code: Alles auswählen

(* konstante Koordinatenbeschleunigung ẍ *)

ẍ=1000000m/sek^2;                                   (* Koordinatenbeschleunigung *)
v0=0m/sek;                                             (* Anfangsgeschwindigkeit *)

c=3*^8m/sek;                                             (* Lichtgeschwindigkeit *)
m=sek=1;                                                            (* Einheiten *)

γ[v_]:=1/Sqrt[1-v^2/c^2]; γ0=γ[v0];                                     (* Gamma *)
v[t_]:=ẍ t+v0 ;                                               (* Geschwindigkeit *)
e[t_]:=c^2 γ[v[t]]-c^2;                        (* spezifische kinetische Energie *)
p[t_]:=v[t]γ[v[t]];                                       (* spezifischer Impuls *)

sol=NDSolve[{τ'[t]==Sqrt[1-v[t]^2/c^2], τ[0]==0, X'[t]==v[t], X[0]==0},
{τ, X}, {t, 0, (c-v0)/ẍ-1},
Method->{"ImplicitRungeKutta", "DifferenceOrder"->20},
MaxSteps->Infinity, InterpolationOrder->All, WorkingPrecision->32];

т[t_]:=Evaluate[τ[t]/.sol];                                         (* Eigenzeit *)
ť[t_]:=т'[t]; ṫ[t_]:=1/ ť[t];                                  (* Zeitdilatation *)
α[t_]:=x''[t];                                      (* Koordinatenbeschleunigung *)
A[t_]:=α[t] γ[v[t]]^3;                                    (* Eigenbeschleunigung *)
x[t_]:=Evaluate[X[t]/.sol][[1]];                                     (* Position *)

plot[f_]:=Plot[f[t], {t, 0, (c-v0)/ẍ-1},
Frame->True, ImagePadding->{{50, 8}, {16, 8}}, ImageSize->320,
PlotRange->All, PlotStyle->Thick, AspectRatio->1/2]

Grid[{{plot[т], plot[ť]},
{"      Eigenzeit τ", "      Zeitdilatation dτ/dt"},
{}, {plot[v], plot[p]},
{"      Geschwindigkeit v", "      Impuls p"},
{}, {plot[x], plot[e]},
{"      Strecke x", "      kinetische Energie"},
{}, {plot[A], plot[α]},
{"      Eigenbeschleunigung a", "      Koordinatenbeschleunigung α"}},
Alignment->Center]

[Yukterez]

KONSTANTE LEISTUNG

 

Bei konstanter Leistung L nimmt die Energie mc²γ linear mit t zu. Daher gilt



mit der hineingesteckten Arbeit W



Nach v aufgelöst ergibt das



Plot mit der Koordinatenzeit t als x-Achse (SI-Einheiten, Impuls und Energie als spezifische Größen pro kg Ruhemasse):



Analytische Lösungen für Eigenzeit τ und Strecke x:

Code:

Code: Alles auswählen

(* konstante Leistung *)

L=10^14 m^2/sek^3;                                       (* spezifische Leistung *)
v0=0m/sek;                                             (* Anfangsgeschwindigkeit *)

c=3*^8m/sek;                                             (* Lichtgeschwindigkeit *)
m=sek=1;                                                            (* Einheiten *)

γ[v_]:=1/Sqrt[1-v^2/c^2]; γ0=γ[v0];                                     (* Gamma *)
v[t_]:=(c Sqrt[(-1+t L/c^2+γ0) (1+t L/c^2+γ0)])/(t L/c^2+γ0); (* Geschwindigkeit *)
e[t_]:=c^2 γ[v[t]]-c^2;                        (* spezifische kinetische Energie *)
p[t_]:=v[t] γ[v[t]];                                      (* spezifischer Impuls *)

sol=NDSolve[{τ'[t]==1/γ[v[t]], τ[0]==0, X'[t]==v[t], X[0]==0}, {τ, X},
{t, 0, 1000}, Method->{"ImplicitRungeKutta", "DifferenceOrder"->20},
MaxSteps->Infinity, InterpolationOrder->All, WorkingPrecision->32];

т[t_]:=Evaluate[τ[t]/.sol];                                         (* Eigenzeit *)
ť[t_]:=т'[t]; ṫ[t_]:=1/ť[t];                                   (* Zeitdilatation *)
x[t_]:=Evaluate[X[t]/.sol][[1]];                                     (* Position *)
α[t_]:=Evaluate[X''[t]/.sol][[1]];                  (* Koordinatenbeschleunigung *)
A[t_]:=α[t] γ[v[t]]^3;                                    (* Eigenbeschleunigung *)

plot[f_]:=Plot[f[t], {t, 0, 1000},
Frame->True, ImagePadding->{{50, 8}, {16, 8}}, ImageSize->320, PlotRange->All,
PlotStyle->Thick, AspectRatio->1/2]

Grid[{{plot[т], plot[ť]},
{"      Eigenzeit τ", "      Zeitdilatation dτ/dt"},
{}, {plot[v], plot[p]},
{"      Geschwindigkeit v", "      Impuls p"},
{}, {plot[x], plot[e]},
{"      Strecke x", "      kinetische Energie"},
{}, {plot[A], plot[α]},
{"      Eigenbeschleunigung a", "      Koordinatenbeschleunigung α"}},
Alignment->Center]

[Yukterez]

Vektor Notation: α ist die Koordinatenbeschleunigung des beschleunigten Beobachters im System des unbeschleunigten Beobachters, a ist die Eigenbeschleunigung des beschleunigten Beobachters in seinem eigenen System, v=βc ist ihre Relativgeschwindigkeit während sie aneinander vorbeifliegen:



Code:

Code: Alles auswählen

β={vx/c,vy/c,vz/c};
γ=1/Sqrt[1-Norm[β]^2];
a={ax,ay,az};
α=(a-((a.β)β)/Norm[β]^2*(1-1/γ))/γ^2;
"α"->Simplify[α]
Quit[]

Code: Alles auswählen

β={vx/c,vy/c,vz/c};
γ=1/Sqrt[1-Norm[β]^2];
α={αx,αy,αz};
a=γ^2(α+((α.β)β)/Norm[β]^2*(γ-1));
"a"->Simplify[a]
Quit[]

Anwendung im Kontext der Schwarzschild Metrik: physics.stackexchange.com/a/842494