Ernst hat geschrieben:Faber hat geschrieben: Im `bewegten' System S'(v) verschieben sich die Atome des Lufballons in negative x-Richtung. Der Luftballon hat auf der rechten Seite eine Sollbruchstelle. In einem anderen `bewegten' System S'(-v) hätte der Luftballon auf der linke Seite eine Sollbruchstelle. Wenn der Luftballon schließlich platzt, lässt sich das in bezug auf S vernünftig erklären. In bezug auf S'(v) und S'(-v) hingegen nicht.
Das kann nicht sein. Ich vermute, das liegt an der begrenzten Anzahl von Strahlen in der Animation oder doch noch in einer Unvollkommenheit der der Animation zugrunde gelegten Beziehungen. Es wäre deshalb gut, wenn jemand die verwendeten Komponentengleichungen für x'(t) und y'(t) doch noch allgemein mathematisch auf x'(t)²+y'(t)²=c²t'² verifizieren könnte. Das wird recht komplex, ich habs bisher nicht hinbekommen.
Jeder Punkt den die Animation zeigt, wird mit ein und derselben Transformation behandelt. Die `Photonen' der Lichtsphäre, die `Atome' des Luftballons, die Eckpunkte der Polygonzüge, die Kreise, Ellipsen oder was auch immer darstellen, alles wird mit ein und demselben Programmcode transformiert.
Die Mathematik dazu habe ich hier erläutert. Hier der Code der entsprechenden Java-Klasse:
Datei com.mahag.neufor.faber.srt.Trajectory.java:
- Code: Alles auswählen
package com.mahag.neufor.faber.srt.shape;
/**
* Abstrakte Basisklasse für Trajektorien.
* <p>
* Abgeleitete Klassen müssen {@code x(t), y(t), z(t)} implementieren.
* {@link #transform(double, double, double)} liefert die Lorentz-transformierte Trajektorie {@code
* x'(t'), y'(t'), z'(t')}.
* </p>
* <p>
* Die Lorentz-transformierte Trajektorie {@code x'(t'), y'(t'), z'(t')} wird wie folgt bestimmt.
* Die Transformationsgleichungen ergeben:
* </p>
*
* <pre>
* x'(t) = gamma * (x(t) - v * t)
* y'(t) = y(t)
* z'(t) = z(t)
* t'(t) = gamma * (t - v/(c*c) + x(t))
* </pre>
* <p>
* Die letzte Gleichung wird mittels Nullstellenbestimmung der Differenz von linker und rechter
* Seite aufgelöst, so dass {@code t(t')} zur Verfügung steht, und dann eingesetzt:
* </p>
* <pre>
* x'(t') = gamma * (x(t(t')) - v * t(t'))
* y'(t') = y(t)
* z'(t') = z(t)
* t'(t') = gamma * (t(t') - v/(c*c) + x(t(t')))
* <p/>
*
* @author Faber@www.mahag.com/neufor
*/
public abstract class Trajectory
{
/** Startzeitpunkt der Trajektorie. */
private final double t0;
/** Endzeitpunkt der Trajektorie. */
private final double t1;
/**
* Liefert neue Instanz.
*
* @param t0
* Startzeitpunkt der Trajektorie.
* @param t1
* Endzeitpunkt der Trajektorie.
*/
protected Trajectory(final double t0, final double t1)
{
this.t0 = t0;
this.t1 = t1;
}
/**
* Zeigt an, ob {@code t} im Bereich der Lebensdauer der Trajektorie liegt.
*/
public boolean isAliveAt(final double t)
{
return t0 <= t && t <= t1;
}
/**
* Liefert den Startzeitpunkt.
*/
public double getT0()
{
return t0;
}
/**
* Liefert den Endzeitpunkt.
*/
public double getT1()
{
return t1;
}
/**
* Liefert {@code x(t)}.
*/
public abstract double getX(double t);
/**
* Liefert {@code y(t)}.
*/
public abstract double getY(double t);
/**
* Liefert {@code z(t)}.
*/
public double getZ(double t)
{
return 0;
}
/**
* Liefert Lorentz-transformierte Trajektorie.
*
* @param c
* Lichtgeschwindigkeit
* @param v
* Relativgeschwindigkeit in x-Richtung des gestrichenen Systems in Bezug auf das
* Laborsystem.
* @param epsilon
* Genauigkeit der Koordinaten der transformierten Trajektorie.
* @return Neue Lorentz-transformierte Trajektorie.
*/
public Trajectory transform(final double c, final double v, final double epsilon)
{
class TransformedTrajectory extends Trajectory
{
/**
* Liefert neue Instanz.
*/
public TransformedTrajectory()
{
super(t0, t1);
}
/*
* @see com.mahag.neufor.faber.srt.shape.Trajectory#getX(double)
*/
@Override
public double getX(double t)
{
final double gamma = 1.0 / Math.sqrt(1 - (v * v) / (c * c));
t = Trajectory.this.getT(t, c, v, epsilon);
return gamma * (Trajectory.this.getX(t) - v * t);
}
/*
* @see com.mahag.neufor.faber.srt.shape.Trajectory#getY(double)
*/
@Override
public double getY(double t)
{
return Trajectory.this.getY(Trajectory.this.getT(t, c, v, epsilon));
}
/*
* @see com.mahag.neufor.faber.srt.shape.Trajectory#getZ(double)
*/
@Override
public double getZ(double t)
{
return Trajectory.this.getZ(Trajectory.this.getT(t, c, v, epsilon));
}
/*
* @see com.mahag.neufor.faber.srt.Trajectory#isAliveAt(double)
*/
@Override
public boolean isAliveAt(double t)
{
t = Trajectory.this.getT(t, c, v, epsilon);
return t0 <= t && t <= t1;
}
}
return new TransformedTrajectory();
}
/**
* Liefert {@code t(t')}.
* <p>
* Der Wert {@code t} wird mittels Nullstellenbestimmung aus der Zeitgleichung der
* Lorentztransformation ermittelt.
* </p>
*
* @param tStrich
* t' (Zeit im gestrichenen System)
* @param c
* Lichtgeschwindigkeit
* @param v
* Relativgeschwindigkeit in x-Richtung des gestrichenen Systems in Bezug auf das
* Laborsystem.
* @param epsilon
* Genauigkeit der Koordinaten der transformierten Trajektorie.
* @return t (Zeit im Laborsystem)
*/
private double getT(double tStrich, final double c, final double v, final double epsilon)
{
final double gamma = 1.0 / Math.sqrt(1 - (v * v) / (c * c));
class Function
{
/**
* Liefert {@code f(t) = tStrich - gamma * (t - v / (c * c) * getX(t))} für die
* Nullstellenbestimmung.
*/
private double f(double t, final double tStrich)
{
return tStrich - gamma * (t - v / (c * c) * getX(t));
}
}
final Function f = new Function();
double t = 0;
final double tEstimate = tStrich / gamma;
double t0 = tEstimate - 5 * (this.t1 - this.t0);
double t1 = tEstimate + 5 * (this.t1 - this.t0);
int k = 0;
while (Math.abs(t1 - t0) > epsilon && k < 100 && Math.abs(f.f(t, tStrich)) > epsilon)
{
t = (t0 + t1) / 2;
if ((f.f(t0, tStrich) * f.f(t, tStrich)) < 0)
{
t1 = t;
}
else
{
t0 = t;
}
k++;
}
return t;
}
}
Für ein Photon oder ein Atom wird eine abgeleitete Klasse erstellt, die z.B. lautet:
Lokale Klasse:
- Code: Alles auswählen
class PhotonOrAtom extends Trajectory
{
private final double alpha;
private final double w;
public PhotonOrAtom(final double alpha, final double w)
{
super(t0, t1);
this.alpha = alpha;
this.w = w;
}
@Override
public double getX(double t)
{
return w * t * Math.cos(alpha);
}
@Override
public double getY(double t)
{
return w * t * Math.sin(alpha);
}
}
Den Rest macht der Code der Trajectory-Klasse für alle Objekte, welche auch immer, immer gleich. Da ist nichts faul. Wenn doch, würde es sich überall zeigen.
Gruß
Faber
