Ki lehet próbálni más sebességekkel is. Az eredmény mindig helyes lesz.
Itt van két példa, v=0.33 és v=0.73 csónak sebességekkel. A c a vízhullám sebessége, most 1.
Újra leírom, a t(23)-t(21) elírás, a számolt érték (t(23)+t(21))/2, hiszen ez az a pont,ahol a csónak-fényóra fél másodpercnél jár. És ez mindig a 10. pont, ami a mérendő vízhullám félideje, tehát a vízhullám hajóhoz mért sebessége állandó.
Illik kis leírást adni a kisérletről.
A 0. idöpont az origó. Innen idul a két óra-szinkronizáló jel a középső csónak közepéről. Mivel az eleje és a vége is fél csónaknyira van a közepétől, ezért egyforma időpontot kell beállítani a két csónak-fényórán. Tehát az 1. és a 21. időpont a mozgó inercia rendszer szerint a 0. időpillanat mindkét órán.
Mint máris kitünik, az egyidejűség relatív volta a vizes kisérletnél is fennáll. A hasonlóság a speciális relativitással nem véletlen. A fény ugyan így egy közeg rezgése. Ha nem így lenne, mindenféle bonyolult drótozást kellene kitalálni, hogy mindig minden fényforrás úgy sugározza a fényt, hogy mindig állandó sebességgel menjen az adott megfigyelőhöz képest. A közegben terjedő rezgésegnél az magától adódik.
Az egyetlen probléma a különböző irányokban különböző relatív sebességgel terjedő jelek konstans sebessége. De mint a csónakos kisérlet mutatja, ennek az oka a fényórákkal megérthető.
A mérendő jel az 1. 10. 11. pontokon halad. A 11. pont triviálisan egyezik a 3. ponttal, a fény 2 hajóhossznyit 1 másodperc alatt tett meg.
Az érdekesebb a 10. pont. Ennek a mozgó rendszer beli idejét a 23.-21. pontok idejéből lehet megkapni. Mint látható az ábrán, a 10. pont ideje pont a 23. és a 21. pontok közt van. Ez annyit jelent, hogy fél másodperc telt el.
Vagyis a mért vízhullám jel a csónakhoz viszonyítva konstans sebességgel terjedt, pont mint a speciális relativitásban,
Nincs több kérdésem.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <X11/Xlib.h>
#include <assert.h>
#include <unistd.h>
Display *dpy;
Window w;
GC gc;
int __gxx_personality_v0;
float s,v=0.6,c=1,dt,x[40],t[40];
void line(int x1,int y1,int x2,int y2,int szin)//vonal ki
{
x1+=400;
x2+=400;
y1=600-y1;
y2=600-y2;
XSetForeground(dpy,gc,szin);
XDrawLine(dpy, w, gc, x1,y1,x2,y2);
}
void drawtext(int x,int y,char *st)//szoveg ki
{
x+=400;
y=600-y;
XDrawString(dpy,w,gc,x,y,st,strlen(st));
}
void marker(int a,int szin)//keresztet rak a pontra es kiirja a szamat
{
char str[100];
printf("%d : %f %f \n",a,x[a],t[a]);
sprintf(str,"%d",a);
drawtext((int)x[a]-10+a,(int)t[a]+10,str);
line((int)x[a],(int)t[a],(int)x[a]+10,(int)t[a],szin);
line((int)x[a],(int)t[a],(int)x[a]-10,(int)t[a],szin);
line((int)x[a],(int)t[a],(int)x[a],(int)t[a]+10,szin);
line((int)x[a],(int)t[a],(int)x[a],(int)t[a]-10,szin);
}
void step(int a,int b,float vv,int szin)//lep egyet [b] az uj, [a]-bol indult
{
x[b]=x[a]+vv*dt;
t[b]=t[a]+dt;
line((int)x[a],(int)t[a],(int)x[b],(int)t[b],szin);
marker(b,szin); //keresztet rak a pontra es kiirja a szamat
}
int specrel()
{
XSetForeground(dpy,gc,0x003000);
for(int ii=0;ii<1000;ii+=20) XDrawLine(dpy, w, gc, ii,0,ii,800);
for(int ii=0;ii<1000;ii+=20) XDrawLine(dpy, w, gc, 0,ii,1000,ii);
x[0]=0;
t[0]=0;
s=50;
{//hatso
dt=(s/2)/(c+v); step(0,1, -c,0xff00ff);//szinkronizalo jel hatra fel hajonyi
dt=s/(c+v); step(1,2, -c,0xff0000);//fenyora
dt=s/(c-v); step(2,3, c,0xff0000);
dt=s/(c-v); step(1,10, c,0xffff00);//merendo jel
dt=s/(c+v); step(10,11, -c,0xffff00);
dt=s/(c-v); step(11,12, c,0xffff00);
dt=s/(c+v); step(12,13, -c,0xffff00);
dt=s/(c+v); step(3,4, -c,0xff0000);//fenyora
dt=s/(c-v); step(4,5, c,0xff0000);
dt=s/(c+v); step(5,6, -c,0xff0000);
dt=(x[5]-x[1])/v; step(1,5, v,0x00ff00);//kozepso csonak vege
dt=(x[6]-x[2])/v; step(2,6, v,0x00ff00);//hatso csonak vege
}
{//elso
dt=(s/2)/(c-v); step(20,21, c , 0xff00ff);//szinkronizalo jel elore fel hajonyi
dt=s/(c-v); step(21,22, c , 0xff0000);//fenyora
dt=s/(c+v); step(22,23, -c , 0xff0000);
dt=s/(c-v); step(23,24, c , 0xff0000);//fenyora
dt=s/(c+v); step(24,25, -c , 0xff0000);
dt=s/(c-v); step(25,26, c , 0xff0000);//fenyora
dt=(x[25]-x[21])/v; step(21,25, v,0x00ff00);//kozepso csonak eleje
dt=(x[26]-x[22])/v; step(22,26, v,0x00ff00);//elso csonak eleje
}
marker(0,0xff00ff);//kezdo pont
printf("t(23)-t(21)%f \n",(t[23]+t[21])/2);
return 0;
}
int main()
{
dpy = XOpenDisplay((0));
w = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0,0, 1000, 800, 0,0,0);
XSelectInput(dpy, w, StructureNotifyMask);
XMapWindow(dpy, w);
gc = XCreateGC(dpy, w, 0, (0));
XSetForeground(dpy,gc,0);
for(;;) { XEvent e; XNextEvent(dpy, &e); if (e.type == MapNotify)break; }
specrel();
XFlush(dpy);
getchar();
return 0;
}
A kép kilóg jobbra, ott vannak a számítási eredmények.
Jobb klikk, viewigame -el látható az egész, vagy , jobb oldali linkblogra klikkelve.
https://m.blog.hu/st/store/image/specfinal.gif
Sajnos, van egy elírás a képen
printf("t(23)-t(21)%f \n",(t[23]+t[21])/2);
Helyesen, mint látható a számítás nem külömbség, hanem a két pont közti érték.
printf("(t(23)+t(21))/2 %f \n",(t[23]+t[21])/2);
Állítólag nem lehet a fény egy közegben terjedő rezgés. Hogy ez mennyire nem így van, azt a legjobban egy kisérlettel lehet belátni. El sem kell végezni valójában a kisérletet, elég számolni, hiszen vízben terjedő rezgésegről lesz szó, aminek a fizikája évszázadok óta ismert. Az igazi kételkedők azért elvégezhetik a kisérletet kedvenc horgásztavukon is, bár nem egyszerű.
A legfontosabb, hogy az idő fogalmát most átdefiniálom. Egy másodperc legyen az az egység, ami alatt egy a csónak orrából küldött hullám eléri a csónak végét, és visszaérkezik. Ezt a fizikában fényórának nevezik, de ott nem a víz hullámai mozognak két pont között, hanem a fény pattok oda-vissza két tükör közt.
A kérdés az, hogy a csónakhoz viszonyítva a víz hullámainak sebessége állandónak mérjük vagy nem. Mert a Michelson-Morley kisérlet szerint a fény állandó sebességgel terjed, függetlenül a forrás és a detektor sebességétől.
Mint itt ki fog derülni, ugyan ez történik a vízben is, ha az időt a víz hullámainak terjedésével mérem.
Legyen három csónakunk. Menetirányban egymás után sorban szorosan haladnak a vizen. Az első és a hátsó szerepe a fényóra eljátszása. Mint írtam, hullámokat gerjesztenek a saját csónakuk elejénél, és amikor a végéről visszaérkezik a jel, akkor telik el egy másodperc. Mivel mozognak, ezért szinkronizálni kell őket, pont ahogy a speciális relativitás is megköveteli. Ott fényjelekkel kell ezt elvégezni, itt vízhullámokkal.
A szinkronizálás után következhet a mérés. Csak annyit kell tenni, hogy a középső csónak végéről vagy az elejéről vízhullámokat kell kelteni, és amikor a csónak másik végéhez ér a hullám, akkor a csónak-fényórákkal lemérni a jel futásidejét.
Mint látható, nem egyszerű kivitelezni a gyakorlatban a kisérletet, de kiszámolni már nem annyira nehéz.
