(* Lokale Finkelsteinbeobachter mit v=-(ve^2)=-2/r *)

im=480;

(* Droste *)

vp=Simplify[(2/r)(1-2/r),r>2]; vm=-vp;

{{"dr/dt"->±vp}}

p1=Show[ParallelTable[Plot[
NIntegrate[1/vp,{r,r1,r2}, WorkingPrecision->32],{r1,2,10},
Frame->True, PlotStyle->{Red,Thick},ImageSize->im, 
AspectRatio->1,PlotRange->{{0,10},{0,10}}, 
GridLines->{{2},{}}, ImagePadding->{{60,2},{30,2}}],
{r2,Join[{2+1/5},Table[2+(3/2)n,{n,0,7}]]}]];

p2=Show[ParallelTable[Plot[
Block[{r1=0},NIntegrate[1/vm,{r,r1,r2}, WorkingPrecision->32]+n],{r2,0,2},
Frame->True, PlotStyle->{Red,Thick},ImageSize->im, 
AspectRatio->1,PlotRange->{{0,10},{0,10}}, 
GridLines->{{2},{}}, ImagePadding->{{60,2},{30,2}}],
{n,0,8,2}]];

p3=Show[ParallelTable[Plot[
-NIntegrate[1/vm,{r,r1,r2}, WorkingPrecision->32],{r1,0,1.999},
Frame->True, PlotStyle->{Red,Thick},ImageSize->im, 
AspectRatio->1,PlotRange->{{0,10},{0,10}}, 
GridLines->{{2},{}}, ImagePadding->{{60,2},{30,2}}],
{r2,{0,1,1.5,1.75}}]];

P1=Show[p1,p2]

(* Raindrop *)

vM=dr/.Solve[dr/(dT-dr (Sqrt[2/r])/(1-2/r))==vm, dr][[1]];
vP=dr/.Solve[dr/(dT-dr (Sqrt[2/r])/(1-2/r))==vp, dr][[1]];
dT=1;

Vm=FullSimplify[vM, r>0]; Vp=FullSimplify[vP, r>2];
{{"dr/dt"->Vm},{"dr/dt"->Vp}}

p1=Show[ParallelTable[Plot[
NIntegrate[1/Vm,{r,r2,r1}, WorkingPrecision->32],{r1,0,10},
Frame->True, PlotStyle->{Red,Thick},ImageSize->im, 
AspectRatio->1,PlotRange->{{0,10},{0,10}}, 
GridLines->{{2},{}}, ImagePadding->{{60,2},{30,2}}],
{r2,Join[{1/2},Table[2+(3/2)n,{n,0,7}]]}]];

p2=Show[ParallelTable[Plot[
NIntegrate[1/Vp,{r,r2,r1}, WorkingPrecision->32],{r1,2.001,10},
Frame->True, PlotStyle->{Blue,Thick},ImageSize->im, 
AspectRatio->1,PlotRange->{{0,10},{0,10}}, 
GridLines->{{2},{}}, ImagePadding->{{60,2},{30,2}}],
{r2,Join[{2.2,2.5},Table[2+(3/2)n,{n,0,7}]]}]];

p3=Show[ParallelTable[Plot[
NIntegrate[1/Vp,{r,r2,r1}, WorkingPrecision->32],{r1,0,1.999},
Frame->True, PlotStyle->{Blue,Thick},ImageSize->im, 
AspectRatio->1,PlotRange->{{0,10},{0,10}}, 
GridLines->{{2},{}}, ImagePadding->{{60,2},{30,2}}],
{r2,{1.999,1.8,1.5,1,1/2}}]];

P2=Show[p1,p2,p3]

(* Finkelstein *)

vM=dr/.Solve[dr/(dT-dr (2/r)/(1-2/r))==vm, dr][[1]];
vP=dr/.Solve[dr/(dT-dr (2/r)/(1-2/r))==vp, dr][[1]];
dT=1;

Vm=FullSimplify[vM, r>0]; Vp=FullSimplify[vP, r>2];
{{"dr/dt"->Vm},{"dr/dt"->Vp}}

p1=Show[ParallelTable[Plot[
NIntegrate[1/Vm,{r,r2,r1}, WorkingPrecision->32],{r1,0,10},
Frame->True, PlotStyle->{Red,Thick},ImageSize->im, 
AspectRatio->1,PlotRange->{{0,10},{0,10}}, 
GridLines->{{2},{}}, ImagePadding->{{60,2},{30,2}}],
{r2,Join[{1/2},Table[2+(3/2)n,{n,0,7}]]}]];

p2=Show[ParallelTable[Plot[
NIntegrate[1/Vp,{r,r2,r1}, WorkingPrecision->32],{r1,2.001,10},
Frame->True, PlotStyle->{Blue,Thick},ImageSize->im, 
AspectRatio->1,PlotRange->{{0,10},{0,10}}, 
GridLines->{{2},{}}, ImagePadding->{{60,2},{30,2}}],
{r2,Join[{2.2,2.5},Table[2+(3/2)n,{n,0,7}]]}]];

p3=Show[ParallelTable[Plot[
NIntegrate[1/Vp,{r,r2,r1}, WorkingPrecision->32],{r1,0,1.999},
Frame->True, PlotStyle->{Blue,Thick},ImageSize->im, 
AspectRatio->1,PlotRange->{{0,10},{0,10}}, 
GridLines->{{2},{}}, ImagePadding->{{60,2},{30,2}}],
{r2,{1.999,1.8,1.5,1,1/2}}]];

P3=Show[p1,p2,p3]

(* Newton *)

v=2/r;

{{"dr/dt"->±v}}

p1=Show[ParallelTable[Plot[
NIntegrate[-1/v,{r,r2,r1}, WorkingPrecision->32],{r1,0,10},
Frame->True, PlotStyle->{Blue,Thick},ImageSize->im, 
AspectRatio->1,PlotRange->{{0,10},{0,10}}, 
GridLines->{{2},{}}, ImagePadding->{{60,2},{30,2}}],
{r2,Join[{1/2},Table[2+(3/2)n,{n,0,13}]]}]];

P4=Show[p1]

Clear[v, τ, r];

(* Grundgerüst in Droste Koordinaten *)

gtt[τ]=1-2/r[τ];grr[τ]=-(1/(1-2/r[τ])); γ[v_]:=(1/(Sqrt[1-(v^2)]));
r'[τ]=((v[τ] γ[v[τ]])/(Sqrt[-grr[τ]])); t'[τ]=(1/((Sqrt[gtt[τ]])(Sqrt[1-((v[τ])^2)])));
Г={-((2 r'[τ] t'[τ])/(((r[τ])^2)-2 r[τ])),-(1/((r[τ])^2))}; Ε=(Sqrt[gtt[τ]])/(Sqrt[1-((v[τ])^2)]);

(* Finkelsteinbeobachter, lokale Geschwindigkeit *)

v[τ_]:=-(2/(r[τ]));

(* Beschleunigung und Kraft *)

f[F_]:=FullSimplify[F,r[τ]>2]; я[f_]:=f/.r[τ]->r
s=f[{"v'"->v'[τ], "r''"->D[r'[τ], τ]}];  я[s][[1]]
t''[τ]=f[D[t'[τ],τ]]; r''[τ]=s[[2,2]];  я[s][[2]]
ẍ=f[{t''[τ],r''[τ]}]; α=f[ẍ-Г]; 
F=f[(Sqrt[Abs[gtt[τ] ((α[[1]])^2)+grr[τ] ((α[[2]])^2)]])];
"\!\(\*SuperscriptBox[\(Г\), \(μ\)]\)"->я[f[Г]]
"((ẍ)^μ)"->я[f[ẍ]]
"(α^μ)"->я[f[α]]
"F"->я[f[F]]

"F"-> я[Simplify[D[Ε,r[τ]],r[τ]>0]]

(* Plot F[r] *)

Plot[я[f[F]],{r,0,4},Frame->True,ImageSize->480,
AspectRatio->1/3, PlotStyle->{Red,Thick}]

(* Raindrop, lokale Geschwindigkeit *)

v[τ_]:=-(Sqrt[(2/(r[τ]))]);

(* Beschleunigung und Kraft *)

f[F_]:=FullSimplify[F,r[τ]>2]; я[f_]:=f/.r[τ]->r
s=f[{"v'"->v'[τ], "r''"->D[r'[τ], τ]}];  я[s][[1]]
t''[τ]=f[D[t'[τ],τ]]; r''[τ]=s[[2,2]];  я[s][[2]]
ẍ=f[{t''[τ],r''[τ]}]; α=f[ẍ-Г]; 
F=f[(Sqrt[Abs[gtt[τ] ((α[[1]])^2)+grr[τ] ((α[[2]])^2)]])];
"\!\(\*SuperscriptBox[\(Г\), \(μ\)]\)"->я[f[Г]]
"((ẍ)^μ)"->я[f[ẍ]]
"(α^μ)"->я[f[α]]
"F"->я[f[F]]

"F"-> я[Simplify[D[Ε,r[τ]],r[τ]>0]]

(* Plot F[r] *)

Plot[я[f[F]],{r,0,4},Frame->True,ImageSize->480,
AspectRatio->1/3, PlotStyle->{Darker[Green],Thick}]

(* Stationärer Beobachter *)

v[τ_]:=0;

(* Beschleunigung und Kraft *)

f[F_]:=FullSimplify[F,r[τ]>2]; я[f_]:=f/.r[τ]->r
s=f[{"v'"->v'[τ], "r''"->D[r'[τ], τ]}];  я[s][[1]]
t''[τ]=f[D[t'[τ],τ]]; r''[τ]=s[[2,2]];  я[s][[2]]
ẍ=f[{t''[τ],r''[τ]}]; α=f[ẍ-Г]; 
F=f[(Sqrt[Abs[gtt[τ] ((α[[1]])^2)+grr[τ] ((α[[2]])^2)]])];
"\!\(\*SuperscriptBox[\(Г\), \(μ\)]\)"->я[f[Г]]
"((ẍ)^μ)"->я[f[ẍ]]
"(α^μ)"->я[f[α]]
"F"->я[f[F]]

"F"-> я[Simplify[D[Ε,r[τ]],r[τ]>0]]

(* Plot F[r] *)

Plot[я[f[F]],{r,0,4},Frame->True,ImageSize->480,
AspectRatio->1/3, PlotStyle->{Blue,Thick}]

(* v = konstant *)

v[τ_]:=-1000;

(* Beschleunigung und Kraft *)

f[F_]:=FullSimplify[F,r[τ]>2]; я[f_]:=f/.r[τ]->r
s=f[{"v'"->v'[τ], "r''"->D[r'[τ], τ]}];  я[s][[1]]
t''[τ]=f[D[t'[τ],τ]]; r''[τ]=s[[2,2]];  я[s][[2]]
ẍ=f[{t''[τ],r''[τ]}]; α=f[ẍ-Г]; 
F=f[(Sqrt[Abs[gtt[τ] ((α[[1]])^2)+grr[τ] ((α[[2]])^2)]])];
"\!\(\*SuperscriptBox[\(Г\), \(μ\)]\)"->я[f[Г]]
"((ẍ)^μ)"->я[f[ẍ]]
"(α^μ)"->я[f[α]]
"F"->я[f[F]]

"F"-> я[Simplify[D[Ε,r[τ]],r[τ]>0]]

(* Plot F[r] *)

Plot[Abs[я[f[F ]]],{r,0,4},Frame->True,ImageSize->480,
AspectRatio->1/3, PlotStyle->{Purple,Thick}]

(* Grundgerüst in Droste Koordinaten *)

Quit[]

gtt=1-2/r; grr=-1/gtt; γ=1/(Sqrt[1-(v^2)]); ṙ=v γ/(Sqrt[-grr]); Ε=(Sqrt[gtt])/(Sqrt[1-(v^2)]);

τ=NIntegrate[(1/(ṙ)),{r,0,2}];

LogLinearPlot[-τ,{v,1,10},ImageSize->480,PlotRange->All,
AspectRatio->1/3, PlotStyle->{Magenta,Thick},Frame->True]

(* Eigenzeit Finkelsteinbeobachter *)

v=-2/r; "τ"->τ

(* Eigenzeit Raindrop *)

v=-(Sqrt[2/r]); "τ"->τ

(* Eigenzeit mit v=1000c *)

v=-1000; "τ"->τ

(* Eigenzeit mit v=1.001c *)

v=-1-1/1000; "τ"->τ

(* Eigenzeit mit E=0 *)

Clear[v,τ, r];"τ"->Limit[Integrate[(1/(ṙ)),{r,0,2}], v->-∞]

v0=0;

Quit[]

sol=NDSolve[{r''[τ]==-1/((r[τ])^2), r'[0]==0, r[0]==2},r[τ],{τ,0,4},
StepMonitor:>(l=p;p=τ;s=p-l;),Method->{"EventLocator",
"Event":>(If[s<1*^-20,0,1])}, WorkingPrecision->32];  "τ"->N[p]