Endgültige Widerlegung der SRT

[galactic32]

Wenn man MM und den vielen anderen Messungen trauen kann, MM trau ich nicht weil ich da technische Unzulänglichkeiten sehe, dann ist eine ganz klar.

So allein vom Gespür her kann ich dem beipflichten.
Gerade die materielle Länge, die die Spiegel in perfecter position hält, macht mir da den totalen Strich durch überhaupt eine plausible Annnahme zum Bezug zum Äther außer, das Materie in sich genauso durch Licht zusammengeahlten wird („kommuniziert“)!

Es spielt keine Rolle wie schnell wir uns gegen den Mikrowellenhintergrund bewegen, auf der Erdoberfläche gilt immer dass dort laufendes Licht so läuft als sei der Bezug dafür an der Erde angenagelt.Als fällt der universale Bezug in Form von CBM weg.

Umgekehrt wird ein Schuh draus.
Die Erde ist im Äther angenagelt.Das Licht flitzt (entspannt sich) eigenzeit-frei von Punkt zu Punkt (zieht sich dort wieder zusammen).
Und gerade den CMB kann man heutzutage offenbar prima rot/blau-verschoben nachweisen.

Denn am Ort gilt immer c+v des bewegten.
Und zwar nicht gegen die CBS, sondern gegen den Ortsbezug.
Und wenn das eine Transformation nicht berücksichtigt dann transformiert sie falsch.

Also da soll einer durchsteigen.
Das Wellenpaket könnte prima als frei (unbewegt) betrachtet werden.Zumindest ist seine Eigenzeit ( im Eigen-Koordinaten-System ) nicht da.
Du formulierst so nicht sehr nachvollziehbar.
c+v hat etwas mit Empfänger Sender zu tun, auch der Ort vom Sender/Empfänger macht Sinn.v relativ zu v=0 einem (virtuellen) ruhenden Punkt im Medium dazu das c der Licht-Fort-Pflanzung mit der EigenZeit zur der Eigen-Länge, so versteh ich's.
Der Sender z.B. ist im Äther/Träger ziemlich festverkittet , die Träge Masse !
Ort macht nur relativ Sinn zu einem Abstand.(Ab drei Orten dreier Punkt(-Massen-Trägheiten) macht das modellieren eines Physik-Verständnis-Gebäudes Sinn (da vernünftigerer Abstand!).
Träge Masse ist veränderbar (gamma-faktor !).
Die Lichtgeschwindigkeit läßt sich ändern (x*c).Ein Object ließe sich im Eigen-System (Eigen-Äther) so verändern, daß es vielfaches der Licht-Gechwindigkeit erreicht!gamma<1 relativ zum Erd-Beobachter.

Wie ist Raum aufgebaut?
Was die Raum-Theorien beschreiben sollten wären die „Gesetze“ wie ist ein Dreieck rechtwinklig?
Wie ist ““Zeit““ rechtwinklig zu einer räumlichen Linie?
Wie schnell „läuft“ Zeit?Sirup-artig (Viskosität)?Oder flink?
Wie schrumpft sich Länge?

Gruß

[galactic32]

Die gezeigte Darstellung der Kreisfläche in der Simulation wäre dann zwar noch in der Weise falsch, da sich kein Kreis sondern eine Ellipse zeigen müßte.
…
Was mir allerdings nicht klar ist, wie man das aus der Transformation herleiten könnte, da y und z nicht transformiert werden.

Andersrum.Die Simulation ist soweit ok.Als eine Ellipse zeigt sie sich zeitlich gedehnt, gedreht und in der Zukunft als Kreis dieses Moment's.
Die Photonen-Pulse sind zu dem Zeit-Punkt schon richtig.
Nur wir sehen instantan die selbe Zeit.(Koordinaten-System-Gleichzeitigkeit ).
Wir sind so etwas wie Super-Beobachter des ganzen System's.
Um jetzt den Punkt zu finden wo und wann der Beobachter B' im Ursprung (0,0,0) ein Licht-Echo dieser Photonen-Pulse erkennt, es seien an dünnem Nebel reichlich helle 8 Licht(-blitzchen) verursacht, hast Du recht, verzieht sich der selbe Zeit-AugenBlick des Photonen-Ordnungs-Zustands (Kreis) zu einer Ellipsenartigen Wahrnehmung.Wir hätten 8 Miniblitze, von denen dann vom im Absoluten Äther weiterreisenden Beobachter B' diese Zeit und Winkel-verdreht gemessen werden.
Etwas Back-Egeneering.
Also was der Beobachter B' Gerade sieht muß umgekehrt verfolgt werden, ist per Lichtstrahl zeitlich in die Vergangenheit zu Verfolgen.Hat Faber ja nicht eingezeigt, was ich vorschlug mit blauen Linien, denn die blauen Strahlen müßten einzeln zurückgerechnet werden.
Mein Hack-Vorschlag war da zu unbedacht!
Wie man sich verprogrammieren kann !?!
Also nicht jeder Animation vertrauen!Mehr durschauen .

Gruß

[galactic32]

Hallo Highway,

Das habe ich, in den Grenzen der Transformationsvorschriften, nicht bestritten.

Ich bezog mich da auf Ellipse sehen.Alleine von B' aus läßt sich das wohl nicht vom Kreis unterscheiden!Kann trianguliert werden?

Aber sie (die Simulation) zeigt, dass die Grundannahme c=constant falsch ist. Sie zeigt, dass t=constant richtig ist.

Das darfst Du den SRT-Fanatikern aber so nicht unter die Nase reiben.
Vielleicht geht noch mehr.
Eine Licht-Frequenz-Raum-Theorie dürfte weitaus weniger verkorkst sein als diese mainstream SR-Hypothesen.
Das 2te Postulat (SRT) ist so was von dogmatisch.
Die Natur wird sich da wohl sehr viel freier Formen lassen.(Bzw. unsere Sicht der Erkenntnisse).
Wie läßt sich denn c genügend genau definieren?
Wie genau t definiert ist, ist noch mal eine genauere Überlegung wert.
Erst mal meinst Du mit t die System-Zeit des Labors?
Wie ist die Reihenfolge?Leitet sich c aud t her?Oder t aus c?Oder ist Reihenfolge daneben (nicht lineare Natur!?)?
Leitet sich Abstand aus c und t her?
Dieses Dreier-System hat wohl einen Einheitlichen Hintergrund.Klingt nach reiner Frequenz-Zeit-Synthese unsere physikalische Natur.
Aber steht das so in den Lern-Büchern?

Wenn die SRT-Leute an Eigen-Zeit und System-Zeit gewöhnt sind , warum sind sie dann nicht offen für Sub-System-Zeit und tiefere Verschachtelungen?
Warum dieses Dogma c sei constant zu sein?
Rechnerisch ganz besonders ließe sich c aus abstand und Zeit generieren.

Die Natur ist da weit aus variierbarer.
B. Heim z.B. rechnete mit weitaus mehr Dimensionen.Auch mehrere „zeitliche“!
Hier noch das was B' gerade „sieht“ zum Zeitpunkt ct'=0.980m' +/- dt':
Es der Photo-Blitz vom Ort (0,0,0) =(x,y,z)=(x',y',z') wo t=t'=0 , der Kreis im S' System mit r=ct'=0.5*0.980m'!
Ich hoff es ist einigermaßen schlüssig ( richtig wag ich gar nicht erst zu sagen ):

Laborsystem_0.png (37.12 KiB) 5491-mal betrachtet

Gruß

[Kurt]

Hallo Highway,

Die Zeit ist das Maß aller Dinge, weil sie auf alles wirkt - das kann Licht nicht von sich behaupten!

das hat nur einen grossen Haken.
Es existiert nichts was als Zeit bezeichnet werden könnte.

Gruss Kurt

[Hannes]

Hallo Faber !

Ich spreche dich mit Absicht mit dem in Forenkreisen üblichen "Du" an,
weil ich deine Arroganz und Selbstherrlichkeit nicht vertragen kann.
Wenn du glaubst, die SRT mit ihrer eigenen Mathematik widerlegen zu können,
wirst du kein Glück haben.Man kann nicht den Teufel mit Beelzebub austreiben.

Es sind wohl genug Fehler in der SRT, aber genausoviele mathematische Hintertürchen,um nicht angenagelt zu werden.
Aus diesem Grund wende ich die SRT -Formeln nur äusserst vorsichtig an.

Denn selbst bei deiner Mathematikbesessenheit hast du den Hauptfehler
der SRT übersehen:
Die SRT hat sich ihre eigene Welt gebaut und hat dabei die Gesetze der
Optik, die vielleicht auch zur Physik gehören könnten, gänzlich
negiert.

Dass ein optisches System Vorrang vor einem Inertialsystem
haben könnte,ist dir nicht in den Sinn gekommen.
Innerhalb eines optischen Systems gilt die Mathematik mit
Inertialsystemen. Außerhalb ist sie falsch.

Mich darfst du ohneweiters mit "Du" ansprechen, wenn ich dir
auch an Lebensjahren weit voraus sein dürfte. Ich scheue mich
nicht,auch mit jedem Studenten freundschaftlich zu verkehren.
Da habe ich sogar mit den Masterminds der Relativisten ein viel
besseres menschliches Verhältnis.

Trotz alledem wünsche ich Dir
frohe Weihnachten !

Hannes

[Mordred]

Es existiert nichts was als Zeit bezeichnet werden könnte.

Dann messen wir mit Uhren etwas imaginäres ?

Gruß Mordred

[Kurt]

Es existiert nichts was als Zeit bezeichnet werden könnte.

Dann messen wir mit Uhren etwas imaginäres ?

Hallo Mordred,

eine Uhr misst nichts, sie zählt.
Und zwar ihre eigenerzeugten Takte.

Gruss Kurt

[Mordred]

Hallo Kurt,

eine Uhr misst nichts, sie zählt.
Und zwar ihre eigenerzeugten Takte.

Messen, zählen, wie auch immer, würde es keine Zeit geben, könnte kein Takt durch den nächsten abgelöst werden.

Gruß Mordred

PS: Zeit ist wie ein Stab.
der Engländer unterteilt ihn in inches, der Deutsche in cm. Beide teilen also den Stab in ihre eigenen Einheiten ein.
Dem Stab ansich ist es aber egal, wer ihn wie einteilt.
Er ist einfach nur da.
Wäre er allerdings nicht da, könnte auch keiner ihn einteilen.

[Faber]

Im Laborsystem breitet sich das Licht ohne Dopplereffekt aus. Im gestrichen System ergibt sich ein Dopplereffekt. Das bedeutet, dass gemäß SRT zwei relativ bewegte Beobachter die Ausbreitung des Lichtes unterschiedlich wahrnehmen.

Ein im Laborsystem ruhender Beobachter wird sagen: Die drei Lichtblitze breiten sich in Form konzentrischer Sphären aus, während ein im gestrichenen System ruhender Beobachter sagen wird: Die (selben) drei Lichtblitze breiten sich in Form nicht-konzentrischer Sphären aus.

Das liegt daran, dass der eine Beobachter gegenüber dem Blitzgerät ruht und der andere nicht.

Vorraussetzung für die SRT sind aber nun die beiden Postulate:

• Relativität (d.h. Beobachterunabhängigkeit) der Lichtausbreitung.
• Konstanz und Isotropie der Lichtausbreitung. D.h. ein Beobachter ruht stets relativ zum Zentrum der sphärischen Lichtausbreitung.

Beide Postulate ergeben gemeinsam:

• Jeder Beobachter ruht stets relativ zum Zentrum der sphärischen Lichtausbreitung.

Wie die Animation unten zeigt, steht laut SRT nicht jeder Beobachter stets im Zentrum der sphärischen Lichtausbreitung. Die Animation zeigt also, dass die SRT mit der Lorentztransformation nicht die beiden Postulate erfüllt.

Gesegnete Weihnacht
Faber

LightSphere-c600.gif (502.52 KiB) 5373-mal betrachtet

LightSphere.java (V1.4):

Code: Alles auswählen

import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;

/**
* Erstellt eine GIF-Datei.
* <p>
* Das animierte Bild zeigt die Ausbreitung eines Lichtblitzes in Form einer Lichtsphäre vom
* Ursprung eines Laborsystems aus sowie die Ausbreitung desselben Lichtblitzes in bezug auf ein zum
* Laborsystem relativ bewegtes, gestrichenes System.
* </p>
* <p>
* Man rufe die {@link #main(String...)}-Methode auf.
* </p>
*
* @author Faber
* @version 1.4
*/
public class LightSphere
{

   /** Breite des Bildes in Pixeln. */
   private final int w = 256 + 128;

   /** Höhe des Bildes in Pixeln. */
   private final int h = 512;

   /** Lichtgeschwindigkeit in m/s. */
   private final double c = 300E6;

   /** Relative Schnelligkeit der Bezugssysteme. */
   private final double v = 0.600 * c;

   /** Gamma-Faktor der Lorentztransformation. */
   private final double gamma = 1.0 / Math.sqrt(1 - (v * v) / (c * c));

   /** Zeit zwischen zwei Blitzen. */
   private final double T = 0.125 / v;

   /**
    * Erstellt die Bilddatei.
    *
    * @see #main(String...)
    */
   private LightSphere()
   {

      final String sv = String.format("%.3f", v / c).substring(2);
      final String fileName = String.format("%s-c%s.gif", LightSphere.class.getSimpleName(), sv);
      final AnimatedGifEncoder gifenc = new AnimatedGifEncoder();
      gifenc.setQuality(10);
      gifenc.setRepeat(0);
      gifenc.setDelay(100);
      gifenc.start(fileName);
      final double t0 = 0; // Startzeitpunkt in Sekunden
      final double t1 = 1 / c; // Endzeitpunkt in Sekunden
      final double dt = (t1 - t0) / 50;
      for (double t = t0; t <= t1; t += dt)
      {
         final BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_3BYTE_BGR);
         final Graphics2D graphics2D = image.createGraphics();
         try
         {
            { // Hintergrund
               graphics2D.setColor(new Color(0xE0E0E0));
               graphics2D.fillRect(0, 0, w, h);
            }
            { // Bilder
               paint(graphics2D, t, true);
               paint(graphics2D, t, false);
            }
         }
         finally
         {
            graphics2D.dispose();
         }
         gifenc.addFrame(image);
      }
      gifenc.finish();
   }

   /**
    * Malt ein Phasenbild der Animation.
    *
    * @param graphics2D
    *           Grafik-Kontext.
    * @param t
    *           Zeitpunkt in Sekunden.
    * @param labor
    *           Zeigt an, ob in bezug auf das Laborsystem gemalt wird.
    */
   private void paint(final Graphics2D graphics2D, final double t, final boolean labor)
   {

      final Color blue = new Color(0x0000A0);
      final Color gray = new Color(0xA0A0A0);
     
      final int R = h / 4;
      final int mx = 3 * R / 2;
      final int my = labor ? R : 3 * R;
      final double scale = 0.9 * R;
      final double u = 1.0 / scale; // gibt die Breite eines Pixels in Metern an
      final double meterPerDiv = 0.25;
      final AffineTransform transform = new AffineTransform();
      transform.translate(mx, my);
      transform.scale(scale, scale);
      final AffineTransform originalTransform = graphics2D.getTransform();
      try
      {
         graphics2D.setTransform(transform);
         graphics2D.setStroke(new BasicStroke((float) u));
         { // Gitter malen
            graphics2D.setColor(gray);
            for (double x = -1.0; x <= 1.0; x += meterPerDiv)
            {
               graphics2D.draw(new Line2D.Double(x, -1, x, 1));
            }
            for (double y = -1.0; y <= 1.0; y += meterPerDiv)
            {
               graphics2D.draw(new Line2D.Double(-1, y, 1, y));
            }
         }
      }
      finally
      {
         graphics2D.setTransform(originalTransform);
      }
      { // Achsen und Text malen.
         final int d = 12;
         graphics2D.setColor(Color.BLACK);
         graphics2D.setStroke(new BasicStroke());
         graphics2D.draw(new Line2D.Double(mx + R, my, mx - R, my));
         graphics2D.draw(new Line2D.Double(mx + R - d, my + d, mx + R, my));
         graphics2D.draw(new Line2D.Double(mx + R - d, my - d, mx + R, my));
         graphics2D.draw(new Line2D.Double(mx, my + R, mx, my - R));
         graphics2D.draw(new Line2D.Double(mx - d, my - R + d, mx, my - R));
         graphics2D.draw(new Line2D.Double(mx + d, my - R + d, mx, my - R));
         graphics2D.drawRect(0, my - R, w - 1, 2 * R - 1);
         final Font font = new Font("Verdana", Font.BOLD, 12);
         final String text = String.format("%s = %.3fm\n", labor ? "ct" : "ct'", c * t);
         final Rectangle2D r = font.getStringBounds(text, graphics2D.getFontRenderContext());
         final int th = (int) (r.getHeight() + 0.5);
         final int tw = (int) (r.getWidth() + 0.5);
         graphics2D.setFont(font);
         graphics2D.drawString(String.format("%.2fm/div", meterPerDiv), w - tw - th, my + R - th);
         graphics2D.drawString(text, w - tw - th, my + R - 2 * th);
         if (!labor)
         {
            graphics2D.drawString(String.format("v = %.3fc", v / c), w - tw - th, my + R - 3 * th);
         }
         graphics2D.drawString(labor ? "Laborsystem" : "Gestr. System", th, my - R + th);
         graphics2D.drawString(labor ? "X" : "X'", (int) (mx + scale + 0.5 * th),
                               (int) (my - 0.5 * th));
         graphics2D.drawString(labor ? "Y" : "Y'", (int) (mx + 1.0 * th),
                               (int) (my - scale - 0.0 * th));
      }
      try
      {
         graphics2D.setTransform(transform);
         graphics2D.setStroke(new BasicStroke((float) u));
         final Color color = labor ? new Color(0x00A000) : new Color(0xA00000);
         final double xBlitz = labor ? 0 : -v * t;
         final double yBlitz = 0;
         final int noOfPhotons = 8;
         final double[] xPhoton = new double[noOfPhotons];
         final double[] yPhoton = new double[noOfPhotons];
         { // Photonen berechnen
            for (int k = 0; k < noOfPhotons; k++)
            {
               final double alpha = 2 * Math.PI * k / noOfPhotons;
               xPhoton[k] = labor ? xLabor(alpha, t) : xStrich(alpha, t);
               yPhoton[k] = labor ? yLabor(alpha, t) : yStrich(alpha, t);
            }
         }
         { // Kreise malen.
            final double x1 = 0;
            final double y1 = 0;
            final double r1 = c * t;
            final double x2 = labor ? 0 : -v * T;
            final double y2 = 0;
            final double r2 = c * (t - T);
            final double x3 = labor ? 0 : -v * 2 * T;
            final double y3 = 0;
            final double r3 = c * (t - 2 * T);
            final Composite originalComposite = graphics2D.getComposite();
            try
            {
               graphics2D.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.3f));
               graphics2D.setColor(color);
               graphics2D.draw(new Ellipse2D.Double(x1 - r1, y1 - r1, 2 * r1 + u, 2 * r1 + u));
               final double d = 4 * u;
               if (!labor)
               {
                  graphics2D.draw(new Line2D.Double(x1 - d, y1 - d, x1 + d, y1 + d + u));
                  graphics2D.draw(new Line2D.Double(x1 - d, y1 + d, x1 + d, y1 - d + u));
               }
               if (t >= T)
               {
                  graphics2D.draw(new Ellipse2D.Double(x2 - r2, y2 - r2, 2 * r2 + u, 2 * r2 + u));
                  if (!labor)
                  {
                     graphics2D.draw(new Line2D.Double(x2 - d, y2 - d, x2 + d, y2 + d + u));
                     graphics2D.draw(new Line2D.Double(x2 - d, y2 + d, x2 + d, y2 - d + u));
                  }
                  if (t >= 2 * T)
                  {
                     graphics2D
                           .draw(new Ellipse2D.Double(x3 - r3, y3 - r3, 2 * r3 + u, 2 * r3 + u));
                     if (!labor)
                     {
                        graphics2D.draw(new Line2D.Double(x3 - d, y3 - d, x3 + d, y3 + d + u));
                        graphics2D.draw(new Line2D.Double(x3 - d, y3 + d, x3 + d, y3 - d + u));
                     }
                  }
               }
            }
            finally
            {
               graphics2D.setComposite(originalComposite);
            }
         }
         { // Verbindungslinien Blitzgerät-Photonen malen.
            final Composite originalComposite = graphics2D.getComposite();
            try
            {
               graphics2D.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.3f));
               for (int k = 0, N = 8; k < N; k++)
               {
                  final double x = xPhoton[k];
                  final double y = yPhoton[k];
                  {
                     graphics2D.setColor(gray);
                     graphics2D.draw(new Line2D.Double(x, y, xBlitz, yBlitz));
                  }
               }
            }
            finally
            {
               graphics2D.setComposite(originalComposite);
            }
         }
         { // Blitzgerät malen.
            final double x = xBlitz;
            final double y = yBlitz;
            {
               final double ry = 4 / scale;
               final double rx = labor ? ry : ry * gamma;
               graphics2D.setColor(blue);
               graphics2D.draw(new Rectangle2D.Double(x - rx, y - ry, 2 * rx + u, 2 * ry + u));
            }
            {
               final double ry = 1 / scale;
               final double rx = labor ? ry : ry * gamma;
               graphics2D.setColor(blue);
               graphics2D.fill(new Rectangle2D.Double(x - rx, y - ry, 2 * rx + u, 2 * ry + u));
            }
         }
         { // Photonen malen.
            for (int k = 0, N = 8; k < N; k++)
            {
               final double x1 = xPhoton[k];
               final double y1 = yPhoton[k];
               {
                  final double r = 3 / scale;
                  graphics2D.setColor(color);
                  graphics2D.fill(new Ellipse2D.Double(x1 - r, y1 - r, 2 * r + u, 2 * r + u));
               }
            }
         }
      }
      finally
      {
         graphics2D.setTransform(originalTransform);
      }
   }

   /**
    * Liefert die x-Komponente der Trajektorie eines Photons.
    *
    * @param alpha
    *           Richtung, in die das Photon im Laborsystem vom Ursprung aus fliegt, in Radian.
    * @param t
    *           Zeitpunkt t im Laborsystem, in Sekunden.
    * @return die x-Position des Photons zum Zeitpunkt t in Metern.
    */
   public double xLabor(final double alpha, final double t)
   {

      return c * t * Math.cos(alpha);
   }

   /**
    * Liefert die y-Komponente der Trajektorie eines Photons.
    *
    * @param alpha
    *           Richtung, in die das Photon im Laborsystem vom Ursprung aus fliegt, in Radian.
    * @param t
    *           Zeitpunkt t im Laborsystem, in Sekunden.
    * @return die y-Position des Photons zum Zeitpunkt t in Metern.
    */
   public double yLabor(final double alpha, final double t)
   {

      return c * t * Math.sin(alpha);
   }

   /**
    * Liefert die x'-Komponente der Trajektorie eines Photons.
    * <p>
    * Herleitung siehe <a href="http://www.mahag.com/neufor/viewtopic.php?p=20494#p20494">hier</a>.
    * </p>
    *
    * @param alpha
    *           Richtung, in die das Photon im Laborsystem vom Ursprung aus fliegt, in Radian.
    * @param tStrich
    *           Zeitpunkt t' im gestrichenen System, in Sekunden.
    * @return die x'-Position des Photons zum Zeitpunkt t' in Metern.
    */
   public double xStrich(final double alpha, final double tStrich)
   {

      final double denominator = (c - v * Math.cos(alpha));
      return c * tStrich * (c * Math.cos(alpha) - v) / denominator;
   }

   /**
    * Liefert die y'-Komponente der Trajektorie eines Photons.
    * <p>
    * Herleitung siehe <a href="http://www.mahag.com/neufor/viewtopic.php?p=20494#p20494">hier</a>.
    * </p>
    *
    * @param alpha
    *           Richtung, in die das Photon im Laborsystem vom Ursprung aus fliegt, in Radian.
    * @param tStrich
    *           Zeitpunkt t' im gestrichenen System, in Sekunden.
    * @return die y'-Position des Photons zum Zeitpunkt t' in Metern.
    */
   public double yStrich(final double alpha, final double tStrich)
   {

      final double denominator = (c - v * Math.cos(alpha)) * gamma;
      return c * tStrich * (c * Math.sin(alpha)) / denominator;
   }

   /**
    * Programmeinstiegspunkt.
    *
    * @param args
    *           wird ignoriert.
    */
   public static void main(final String... args)
   {

      new LightSphere();
   }
}


[Kurt]

Hallo Kurt,

eine Uhr misst nichts, sie zählt.
Und zwar ihre eigenerzeugten Takte.

Messen, zählen, wie auch immer, würde es keine Zeit geben, könnte kein Takt durch den nächsten abgelöst werden.

Andersrum.
Da es einen Takt gibt, den Trägertakt, lässt sich daraus etwas zusammenzählen und mit dem Namen Zeit belegen.
Gäbe es diesen Takt nicht würde es nur Stillstand geben.
Die Trägheit ist der lebendige Beweis dafür.

Gruss Kurt