Keresés

Részletes keresés

sat3 Creative Commons License 2012.09.15 0 0 853

Ha frekvenciák szerint szeretné valaki beállítani az egészet, akkor azt valahogy így:

 

f=0.3;

fs=0.1;

 

D=f*2.0*M_PI;

D*=D;

 

amplitudo[index]=sin(time*fs*2.0*M_PI);

 

 

 

A forrás frekije (fs) jobb ha alacsonyabb, mint a közegé, mert komplikációk léphetnek fel.

A prizmához fel lehet venni egy harmadik frekit.

fk=0.2;

Dk=fk*2.0*M_PI;

Dk*=Dk;

 Ekkor:
        if(prizman_belul[index])
            sebesseg[index] -= (amplitudo[index]-alap)*Dk*dt;
        else
            sebesseg[index] -= (amplitudo[index]-alap)*D*dt;

 

 

 

Ha a periódusidő túl kicsi (1/f) ,akkor a dt-t, azaz a delta time-ot kisebbre kell venni,

 

Előzmény: sat3 (842)
sat3 Creative Commons License 2012.09.15 0 0 852

Közben a csillagvárosban egy jó link került.

 

 

http://profmattstrassler.com/articles-and-posts/particle-physics-basics/the-known-apparently-elementary-particles/the-known-particles-if-the-higgs-field-were-zero/

 

This linking of the top-left and the top-right is not to be confused with the binding of two particles into a composite object, as a proton and an electron are bound together by the electromagnetic force to form a hydrogen atom. It is a different kind of combining, in which two elementary particles are mixed together into a single elementary particle.

 

Mintha valahol olvastam volna hasonlót.

Ja, ebben a topikban.. xD

 

 

 

 

sat3 Creative Commons License 2012.09.15 0 0 851

Sőt, elérhető az is, hogy csak egy bizonyos mélységig hatoljon be a közegbe a hullám.

 

D=1.8     amplitudo[index]=sin(time*1.8)

Előzmény: sat3 (849)
sat3 Creative Commons License 2012.09.15 0 0 850

A rugóállandó és a freki kapcsolata:

D=m*(2* pi* f)^2

 

Ahogy elnézem, mostanában k-val jelölik, ami nem túl jó ötlet, mert az a hullámszám jele,

Előzmény: sat3 (849)
sat3 Creative Commons License 2012.09.15 0 0 849

A frekvenciák arányának variálásával az is elérhető, hogy a hullám ne lépjen be a közegbe.

D=0.9     amplitudo[index]=sin(time*1.1)

 

 

D=1.9     amplitudo[index]=sin(time*2.1)

 

 

Előzmény: sat3 (844)
sat3 Creative Commons License 2012.09.15 0 0 848

Csatolt harmónikus oszcillátorok

 

 

Nagyon szemléletes, ahogy az eredő hullám egy határozott irányba tart.

Pedig az oszcillátorok minden irányban kapcsolódnak a szomszédjukhoz. Mégsem terjed szét az eredő hullám minden irányba,

Egy adott ponttól az elemi hullám mindefele terjed, hiszen az adott oszcillátor minden szomszédját rezgésbe hozza, de mi már csak az eredő hullámot látjuk, a konstruktív interferencia-helyeket.

 

 

Előzmény: sat3 (847)
sat3 Creative Commons License 2012.09.15 0 0 847

        amplitudo[index] += sebesseg[index]*dt;
        sebesseg[index] -= (amplitudo[index]-alap)*D*dt;

 

A lényeg ennyi.

Harmónikus oszcillátorok sokasága. Mintha a QFT és más QM elméleteknél már hallottunk volna ezekről.

 

 

 

 

Közben eszembe jutott, hogy egy kézzel megrajzolt képből is fel lehetne tölteni a

prizman_belul[]  tömböt, így meg lehetne rajzolni különféle alakú prizmákat, vagy lencséket.

Egész jó oktatóprogram lehetne ebből.

 

A program linuxon fut. xorg-dev, xorg-devel vagy libX11-devel csomagot kell installálni, a linux disztrótól függően.

Előzmény: sat3 (842)
sat3 Creative Commons License 2012.09.15 0 0 846

http://www.algodoo.com/wiki/Rainbows_(lesson)

 

Lehetne még ilyen egyszerűsített szimulációt is írni, ahol a törésmutató szerint lehetne számolni a fénysugár elhajlási szögét a felületen, Ez gyorsabb lenne, de ez egy egyszerűsítés.

 

A hullámok szuperpoziciója adja meg a magyarázatot a jelenségre.

Előzmény: sat3 (845)
sat3 Creative Commons License 2012.09.15 0 0 845

Nos, remélem mostmár látod, miért zavartak el a fizikusok.

Mert ők értik, miért viselkednek így a hullámok. A problem az, hogy ez egy elég összetett valami,

 

Ugyan hogyan lehetne ezt elmagyarázni néhány szóval?

Sehogy.

 

Előzmény: Aparadox (837)
sat3 Creative Commons License 2012.09.15 0 0 844

    int index=(y<<u2)+x;


        int index1=((y&(u-1))<<u2)+x;

 

 

Programozni nem tudóknak talán érdemes leírnom, miért írok ilyen  rusnya sorokat.

Az ok a gyorsítás. Igy gyorsabb az egész. A jelek mögöttes tartalma pedig egyszerű. A y<<u2 egyenértékű az y*256 utasítással.

Miért? Mert a léptetés egy helyiértékkel viszi arrébb a számot. Olyan ez, mikor mi a 100 után teszünk mégegy nullát. Tízzel szoroztunk.

Az eltérés annyi, hogy itt 2-es számredszerben kell gondolkodni olyan esetekben, amikor bitműveleteket végzünk.

A tízes helyiértékek balról jobbra sorba 1 10 100. ..., a kettesnél 1 2 4 8 16 32 64 128 256. Az 1-esből 256-lesz, ha 8-al balra toljuk el. A << ezt az irányt jelöli, Ellentétes irány esetén osztunk az adott lépéshez tartozó számmal. Ez a szám n=2^lépésszám.

 

Az y&(u-1) lekorlátozza az y számot 0 és u értéke közé akkor, ha az u kettő valamelyik hatványa.

A működési elve kissé nehezebben érthető a bitműveletek ismerete nélkül.

A programban az u=256. Ez binárisan 1 0000 0000. ha ebből levonok egyet, akkor lesz belőle 255, azaz 0 1111 1111. Az &-jel az AND bitműveletnek felel meg. Az akkor ad 1-es bitértéket, ha mindkét bemenet 1. Mivel csak az alső 8 bitje 1-es a maszknak(ami most az u-1) , ezért csak az alsó 8 bit fog megmaradni az y-ból.

 

 

Nem kell bitekben gondolkodni a programozás során. Hiszen az int index az végeredményben egy közönséges decimális szám számunkra. Egyszerűen írhatnám az, hogy int index=y*256 +x. csak az kissé lassabban futna le,

Vagy írhatnám az, hogy int index1=((y%u)*256)+x; ahol a %-jel az osztás maradékát adja. Az eredmény ugyan az.

 

De jó tudni, hogy az a gépben egy bináris szám, és kezelhetjük úgy is.

 

 

 

Előzmény: sat3 (842)
sat3 Creative Commons License 2012.09.15 0 0 843

Mit számol a program? Mert szemmel láthatóan teljesen más, mint az előző.

Előszőr is készít egy táblázatot arról, hogy melyik pixel van a prizmán belül. Ezt tárolja a prizman_belul[] tömb. 

így a szimuláció sokkal gyorsabb, nem kell mindig újra és újra ugyanazt kiszámolni feleslegesen.

 

A D betű már elárulja a fizikát értőknek, hogy itt rugó-szimuláció látható. Ez a rugóállandó jele.

A lehető legegyszerűbben van felépítve a program, hogy minél gyorsabban fusson. Ez egy bevált szokás.

Például nincs tömeg a programban. Vagyis  m=1.

 

Minden pixelhez tartozik még egy amplitudo[]  és sebesseg[] ,avagy minden pixel egy rugó. Ezek a rugók egyetlen felületet alkotnak. Minden rugó érzi a 4 szomszédját. Az amplitudójának a nullpontja ezek átlaga.

alap=amplitudo[index1]+amplitudo[index2]+amplitudo[index3]+amplitudo[index4];
        alap*=(1.0/4.0);

Ez teljesen olyan, mintha a négy szomszéd egy síkot jelölne ki, és az adott rugó ehhez a síhoz képest nyúlna meg.

 

Ez a sor a hullámforrás mozgását adja meg. Néhány pixel állandóan rezeg.

amplitudo[index]=sin(time*0.4);

 

A D a prizmákon belül érvényes, azon kívül 1.5D.

*D*dt*1.5;

Előzmény: sat3 (842)
sat3 Creative Commons License 2012.09.15 0 0 842

 

//g++ x.cpp -lX11


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <X11/Xlib.h>


#include <map>
using namespace std;


#define igaz true
#define hamis false
#define visszater return



Display *dpy;
Window win;
GC gc;

void pont(int x,int y,int szin)
{
    XSetForeground(dpy,gc,szin);
    XDrawPoint(dpy, win, gc, x,y);
}
void vonal(int x1,int y1,int x2,int y2,int szin)
{
    XSetForeground(dpy,gc,szin);
    XDrawLine(dpy, win, gc, x1,y1, x2,y2);
}


#define gyok sqrt


//#define float1 double
#define float1 float


struct float2
{
float1 x,y;

float2() {x=y=0;};
float2(float1 x2,float1 y2) {x=x2;y=y2;}
};

float1 skalar(float2 v1,float2 v2) { return (v1.x*v2.x + v1.y*v2.y );}

float1 hossz(float2 v1) {return gyok(skalar(v1,v1));}

float2 normalt(float2 v1)
{
    float1 q=hossz(v1);
    v1.x/=q;
    v1.y/=q;
    visszater v1;
}
float1 frand(float1 n)
{
    return n*(float1)(rand()%20000)/20000.0;
}









struct adat
{
    float2 v1;
    int tipus;
};
map<float1,adat> pontok;



void metszet(float2 &v1,float2 &v2,float2 &u1,float2 &u2,int i)
{
    float2 ir1,ir2, nor,tmp,metszespont;


    ir1.x=v2.x-v1.x;
    ir1.y=v2.y-v1.y;
    float1 h1=hossz(ir1);    
    ir1.x /= h1;
    ir1.y /= h1;
    
    ir2.x=u2.x-u1.x;
    ir2.y=u2.y-u1.y;
    float1 h2=hossz(ir2);    
    ir2.x /= h2;
    ir2.y /= h2;
    nor.x= ir2.y;
    nor.y=-ir2.x;    



    tmp.x=v1.x-u1.x;//u1
    tmp.y=v1.y-u1.y;
    float1 tav= (0.0- skalar(tmp,nor)) / skalar(ir1,nor);
    if(tav>=0.0)
    if(tav<=h1)
    {
        metszespont.x = v1.x + ir1.x*tav;
        metszespont.y = v1.y + ir1.y*tav;
        
        tmp.x = metszespont.x - u1.x;
        tmp.y = metszespont.y - u1.y;
        float1 tav2=skalar(tmp,ir2);
        
        if(tav2>=0.0)
        if(tav2<=h2)
        {
            adat ad;
            ad.v1=metszespont;
            ad.tipus=i;
            
            pontok[tav]=ad;
        }
    }
}
float2 sarkok[2][5];
int prizman_belul[600*600];
float1 amplitudo[600*600] ,sebesseg[600*600];

bool belul(float2 v1)
{
    for(int i=0;i<2;i++)
    {
        pontok.clear();
        metszet(v1,sarkok[i][4],sarkok[i][0],sarkok[i][1],i);
        metszet(v1,sarkok[i][4],sarkok[i][1],sarkok[i][2],i);
        metszet(v1,sarkok[i][4],sarkok[i][3],sarkok[i][2],i);
        metszet(v1,sarkok[i][4],sarkok[i][0],sarkok[i][3],i);
        if(pontok.size()==0)
                        visszater igaz;
    }
    visszater hamis;
}



int main()
{
 
dpy = XOpenDisplay(0);
win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0,0, 600, 600, 0,0,0);

XSelectInput(dpy, win, StructureNotifyMask);
XMapWindow(dpy, win);
gc = XCreateGC(dpy, win, 0, 0);

for(;;) { XEvent e; XNextEvent(dpy, &e); if (e.type == MapNotify) break; }



    sarkok[0][0]=float2(135+10,95);
    sarkok[0][1]=float2(200-10,95);
    sarkok[0][2]=float2(200,145);
    sarkok[0][3]=float2(135,145);

    sarkok[0][4].x=(sarkok[0][0].x+sarkok[0][1].x+sarkok[0][2].x+sarkok[0][3].x)/4.0;
    sarkok[0][4].y=(sarkok[0][0].y+sarkok[0][1].y+sarkok[0][2].y+sarkok[0][3].y)/4.0;
    
    
    sarkok[1][0]=float2( 70,150);
    sarkok[1][1]=float2(200,150);
    sarkok[1][2]=float2(200-10,200);
    sarkok[1][3]=float2( 70+10,200);

    sarkok[1][4].x=(sarkok[1][0].x+sarkok[1][1].x+sarkok[1][2].x+sarkok[1][3].x)/4.0;
    sarkok[1][4].y=(sarkok[1][0].y+sarkok[1][1].y+sarkok[1][2].y+sarkok[1][3].y)/4.0;
    


 

int u=256,u2=8;// 2^u2 = u
for(int y=0;y<u;y+=1)
for(int x=0;x<u;x+=1)
{
    if(belul(float2(x,y)))
    {
        prizman_belul[y*u+x]=1;
    }
    else
        prizman_belul[y*u+x]=0;
        
    pont(x,y,prizman_belul[y*u+x]*250);
}

float1 time=0;
float1 D=0.2,dt=0.5;//0.3

while(1)
{

    for(int y=200;y<222;y+=1)
    for(int x=10;x<30;x+=1)
    {
        int index=(y<<u2)+x+y-200;

        amplitudo[index]=sin(time*0.4);
    }
    for(int y=0;y<u;y+=1)
    for(int x=0;x<u;x+=1)
    {
        int index=(y<<u2)+x;
    
        if(amplitudo[index]> 1.0) amplitudo[index]=1.0;
        if(amplitudo[index]<-1.0) amplitudo[index]=-1.0;
        amplitudo[index] += sebesseg[index]*dt;
    }
    for(int y=1;y<u-1;y+=1)
    for(int x=1;x<u-1;x+=1)
    {
        int index=(y<<u2)+x;
        int index1=(((y+1)&(u-1))<<u2)+((x));
        int index2=(((y-1)&(u-1))<<u2)+((x));
        int index3=(((y))<<u2)   +((x+1)&(u-1));
        int index4=(((y))<<u2)   +((x-1)&(u-1));
    
        float1 alap=amplitudo[index1]+amplitudo[index2]+amplitudo[index3]+amplitudo[index4];
        alap*=(1.0/4.0);
        if(prizman_belul[index])
            sebesseg[index] -= (amplitudo[index]-alap)*D*dt;
        else
            sebesseg[index] -= (amplitudo[index]-alap)*D*dt*1.5;
    }
    for(int y=0;y<u;y+=1)
    for(int x=0;x<u;x+=1)
    {
        int index=(y<<u2)+x; // <<u2 == *u

#if 1
        int szin=127+amplitudo[index]*120.0;
#else
        int szin=amplitudo[index]*250.0;
#endif
        if(szin<0) szin=0;
        if(prizman_belul[index]) szin<<=16;
        pont(x,y,szin);
    }

    time+=dt;
    XFlush(dpy);
}
    XFlush(dpy);
getchar();

return 0;
}

Előzmény: sat3 (841)
sat3 Creative Commons License 2012.09.15 0 0 841

Miközben lassan feladtam, hogy reflektált sugarakat fogok itt számolni /GPU nélkül./, rájöttem, hogy nem kell feltétlenül a Feynman-módszer. A hagyományos és jól bevált hullámterjedéssel pár perc alatt megkapom az összes reflektált hullámot. Sőt, a hullám lassulása a közegben szemmel láthatóvá vált.

 

 

 

 

 

 

 

Előzmény: sat3 (840)
sat3 Creative Commons License 2012.09.12 0 0 840

Majd megpróbálom szemléletesen szimulálni, mert ehhez egy állókép már kevés lesz.

Előzmény: Aparadox (837)
sat3 Creative Commons License 2012.09.12 0 0 839

Amikor egyetlen foton halad az anyagban, a szétterjedő valószínűségi hulláma eléri a környezetében levő atomokat. Ha a közeg atomjai vagy molekulái olyan tulajdonságúak, hogy képesek kölcsönhatásba lépni a fotonnal, akkor ezek a lehetőségek megjelennek a foton valószínűségi függvényében. Ezek általába időigényes folyamatok, így fázisletolódást okoznak a hullámfüggvényben.

Ez a fáziseltolódás hullámok összegzésénél a csoportsebesség csökkenését vonja maga után.

 

Az egészet legegyszerűbb klasszikusan elképzelni. A minden irányba terjedő hullám polarizálja a közeget, ami újabb hullámokat ad a bejövő hullámhoz, de időkéséssel. 

Előzmény: sat3 (838)
sat3 Creative Commons License 2012.09.12 0 0 838

Mármint nekem?

Saját szavam talán nem lenne elég meggyőző. Inkább idézek.

 

http://en.wikipedia.org/wiki/Photon

Photons in matter:

"In a classical wave picture, the slowing can be explained by the light inducing electric polarization in the matter, the polarized matter radiating new light, and the new light interfering with the original light wave to form a delayed wave. In a particle picture, the slowing can instead be described as a blending of the photon with quantum excitations of the matter (quasi-particles such as phonons and excitons) to form a polariton; this polariton has a nonzero effective mass, which means that it cannot travel at c."

...

"Alternatively, photons may be viewed as always traveling at c, even in matter, but they have their phase shifted (delayed or advanced) upon interaction with atomic scatters: this modifies their wavelength and momentum, but not speed.[89] A light wave made up of these photons does travel slower than the speed of light. In this view the photons are "bare", and are scattered and phase shifted, while in the view of the preceding paragraph the photons are "dressed" by their interaction with matter, and move without scattering or phase shifting, but at a lower speed."

 

Röviden összefoglalom. Azért lassul a foton az anyagban,mert valójában egy hullám. Az ok ismét a szuperpozició.

A második idézet sokkal szemléletesebb. Hiszen ez arra a kérdésedre is választ ad, hogy miért "gyorsul" fel újra a foton, miután elhagyta az anyagot.

Valójában se nem lassul, se nem gyorsul, hanem mindig c-vel halad.

A fázisa tolódik el különféle okok miatt . /és függően attól, milyen modellel írjuk éppen le./

 

 

Ha valami részletesebbet akarsz:

http://cops.nano-cops.com/sites/default/files/wubs.pdf

Nem lesz egyszerű végiglapozni sem. xD

 

 

Ez meg csak úgy, mert érdekes.

http://physics.stackexchange.com/questions/1361/scattering-of-light-by-light-experimental-status

Előzmény: Aparadox (837)
Aparadox Creative Commons License 2012.09.11 0 0 837

Szeretném megtudni, hogy mit mond a Fény sebességéről az Új Fizika Fórum beszélgető társasága?

Talán nem érdektelen feltenni a kérdést, hogy vákuumban miért éppen c a fény sebessége. Máshol meg nem. Felhozok egy példát a probléma megvilágítására:

 

     Vegyük szemügyre a lenyugvó Nap sugarait, amint áthatolnak szobánk ablakán. A fotonok a „normál” 300 millió méter másodpercenkénti sebességgel haladnak a Naptól egészen az ablaküvegig. Az üvegnél azonban lelassulnak, sebességük az üvegben 300 helyett már csak 210 lesz.

     Ezt a sebességet tartják mindaddig, amíg az üvegen belül haladnak. Érdemes felfigyelni rá, hogy a sebesség-csökkenés arányában a hullámhosszuk is lecsökken.

    De mi történik a fénysugárral, amikor végre ismét kijut a levegőbe? Milyen sebességgel halad tovább? Az bizony felgyorsul, és mintha mi sem történt volna, ismét 300-al folytatja útját.

    Amikor eléri a második ablaküveget, akkor újra lelassul, majd kilépve újra felgyorsul. Ezt a bravúrt akár 100-szor is véghezviszi, ha 100 üveglapot helyezünk az útjába!

 

Szinte lehetetlen, hogy a foton nevű piciny golyócskának titkos energiatartálya legyen, melybe eltárolja a mozgási energiát, majd amikor gyorsítania kell, akkor újra előveszi és felhasználja.

Ám akár mennyire lehetetlennek is tartom én a Fórum tagságától egyéb, kézenfekvő magyarázatok is jöhetnek. Kíváncsian várom!

 

 

Aparadox

sat3 Creative Commons License 2012.09.10 0 0 836

Nos, ahhoz többet kellene számolnia a gépnek, amit nem tudok most kivárni.

A prizmákon másodlagos hullámforrásokat kellene számolni, amitől nagyon lelassulna a futásidő,

 

Ráadásul módosítani kellene a programot,  hiszen most nem azt számolja, hogy a fénysugár merre fog haladni, hanem azokat a legvalószínűbb pályákat mutatja meg, amelyeken az A pontból a B-be el lehet jutni a legrövidebb idő alatt.

 

Előzmény: sat3 (829)
sat3 Creative Commons License 2012.09.09 0 0 835

Ugye az lenne a logikus, ha a metszéspontok sorba lennének rendezve.

Nos, rendezve vannak.

A   pontok[tav]=ad; sor rendezi, hiszen a pontok[] az map<> tipusú, ami értékadásnál kulcs szerint rendez.

Előzmény: sat3 (827)
sat3 Creative Commons License 2012.09.09 0 0 834

A kanyarodás másodlagos. A lényeg a hullámok szuperpoziciója. Az hozza létre a konstruktív interferenciahelyeket, amelyek kagyarogva érik el a célt.

 

De valójában a foton az összes lehetséges úton halad a célja felé.

Előzmény: sat3 (833)
sat3 Creative Commons License 2012.09.09 0 0 833

És hogy nehogy elszállj magadtól, igazából ezeket nem neked írom, mert tudom, hogy nem fogsz tudni vele mit kezdeni,

Átlépsz ezeken a lényegtelen részleteken, hiszen te tudod, hogy hogyan kanyarodik a fénysugár.

 

Azoknak írtam ezeket le a részleteket, akik tényleg érteni szeretnék ezt az egészet.

Előzmény: Aparadox (811)
sat3 Creative Commons License 2012.09.09 0 0 832

Valójában az összes lehetséges utat nézi a program, hiszen az adott képpont szinét úgy határozza meg, hogy a képpont közelében elhalató 81 fénysugár interferenciáját számolja,

Aki látta Feynman előadását, az tudja, hogy a nagyon valószínűtlen pályák fázisai kis távolságon nagyot változnak, így a szuperpozició kiejti ezeket. Az eredő amplitudó ott zéró. Nos, az ilyen helyek fekete szint kapnak. Tehát a program az összes lehetséges utat számolja, csakhogy azok a helyek, ahol kicsi a valószínűtsége a foton elhaladásának, feketék.

Előzmény: sat3 (830)
sat3 Creative Commons License 2012.09.09 0 0 831

Nekem magyarázol a geometriáról?

haha vicces.

 

 

Előzmény: Aparadox (810)
sat3 Creative Commons License 2012.09.09 0 0 830

..és a mag csak ennyi.

 

     for(int x3=-40;x3<41;x3++)
    {
        kep.x=x+0.5*(frand(2.0)-1.0);            
        kep.y=y+0.5*(frand(2.0)-1.0);

        fazis =  calc(forras,kep, k1,k2);
        fazis += calc(kep,cel,    k1,k2);

        amplitudo.x += cos(fazis);
        amplitudo.y += sin(fazis);
        u++;
    }

 

A program további részei csak kiegészítő funkciót látnak el.

A metszet() két egyenes metszéspontját számolja, a calc() pedig a metszéspontok közti szakaszokra eldönti, hogy k1 vagy k2 hullámszámmal kell ott számolni,

 

és ami lényeg még:

fazis += hossz(diff)*k1;

 

 

A program forgó vektorokkal számol, nem komplex számokkal, de az eltérés az eredményben jelentéktelen.

Előzmény: sat3 (827)
sat3 Creative Commons License 2012.09.09 0 0 829

? ? ?

 

Tudod, azon a képen azért van annyi fénysugár, mert úgy állítottam be a forrást, hogy több eltérő szögben csapódjon a felületbe.

Mivel értem az alapokat, ezért úgy kontrollálom a paramétereket, hogy nagyjából mindig az történik, amit szeretnék.

 

Tudom, mi lesz a következő reakciód. Hol vannak a reflektált sugarak?

Nos, ahhoz többet kellene számolni, amire nekem most nincs időm.

A program egy egyszerűsítés, de a Feynman elképzelésre épül. Nem veszi figyelembe az összes lehetséges utat, csak az adott egyenes közelében levőket. Ennek ellenére elég jól megmutatja, hogy a bal alsó fehér kereszttől hogyan juthat el a foton a két üvegen át a jobb felső fehér keresztig a legrövidebb idő alatt.

Előzmény: Aparadox (811)
sat3 Creative Commons License 2012.09.09 0 0 828

"Van-e egyáltalán önálló gondolatod?"

 

Több, mint bárki másnak.

Előzmény: Aparadox (813)
sat3 Creative Commons License 2012.09.09 0 0 827

Javított változat.

 

 

 

//g++ x.cpp -lX11


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <X11/Xlib.h>


#include <map>
using namespace std;


#define igaz true
#define hamis false
#define visszater return



Display *dpy;
Window win;
GC gc;

void pont(int x,int y,int szin)
{
    XSetForeground(dpy,gc,szin);
    XDrawPoint(dpy, win, gc, x,y);
}
void vonal(int x1,int y1,int x2,int y2,int szin)
{
    XSetForeground(dpy,gc,szin);
    XDrawLine(dpy, win, gc, x1,y1, x2,y2);
}


#define gyok sqrt


//#define float1 double
#define float1 float


struct float2
{
float1 x,y;

float2() {x=y=0;};
float2(float1 x2,float1 y2) {x=x2;y=y2;}
};

float1 skalar(float2 v1,float2 v2) { return (v1.x*v2.x + v1.y*v2.y );}

float1 hossz(float2 v1) {return gyok(skalar(v1,v1));}

float2 normalt(float2 v1)
{
    float1 q=hossz(v1);
    v1.x/=q;
    v1.y/=q;
    visszater v1;
}
float1 frand(float1 n)
{
    return n*(float1)(rand()%20000)/20000.0;
}









struct adat
{
    float2 v1;
    int tipus;
};
map<float1,adat> pontok;



void metszet(float2 &v1,float2 &v2,float2 &u1,float2 &u2,int i)
{
    float2 ir1,ir2, nor,tmp,metszespont;


    ir1.x=v2.x-v1.x;
    ir1.y=v2.y-v1.y;
    float1 h1=hossz(ir1);    
    ir1.x /= h1;
    ir1.y /= h1;
    
    ir2.x=u2.x-u1.x;
    ir2.y=u2.y-u1.y;
    float1 h2=hossz(ir2);    
    ir2.x /= h2;
    ir2.y /= h2;
    nor.x= ir2.y;
    nor.y=-ir2.x;    



    tmp.x=v1.x-u1.x;//u1
    tmp.y=v1.y-u1.y;
    float1 tav= (0.0- skalar(tmp,nor)) / skalar(ir1,nor);
    if(tav>=0.0)
    if(tav<=h1)
    {
        metszespont.x = v1.x + ir1.x*tav;
        metszespont.y = v1.y + ir1.y*tav;
        
        tmp.x = metszespont.x - u1.x;
        tmp.y = metszespont.y - u1.y;
        float1 tav2=skalar(tmp,ir2);
        
        if(tav2>=0.0)
        if(tav2<=h2)
        {
            adat ad;
            ad.v1=metszespont;
            ad.tipus=i;
            
            pontok[tav]=ad;
        }
    }
}
float2 sarkok[2][5];

bool belul(float2 v1)
{
    for(int i=0;i<2;i++)
    {
        pontok.clear();
        metszet(v1,sarkok[i][4],sarkok[i][0],sarkok[i][1],i);
        metszet(v1,sarkok[i][4],sarkok[i][1],sarkok[i][2],i);
        metszet(v1,sarkok[i][4],sarkok[i][3],sarkok[i][2],i);
        metszet(v1,sarkok[i][4],sarkok[i][0],sarkok[i][3],i);
        if(pontok.size()==0)
                        visszater igaz;
    }
    visszater hamis;
}

float1 calc(float2 v1,float2 v2,float1 k1,float1 k2)
{
    int tipus1=3,tipus2=3;
    
    for(int i=0;i<2;i++)
    {
        pontok.clear();
        metszet(v1,sarkok[i][4],sarkok[i][0],sarkok[i][1],i);
        metszet(v1,sarkok[i][4],sarkok[i][1],sarkok[i][2],i);
        metszet(v1,sarkok[i][4],sarkok[i][3],sarkok[i][2],i);
        metszet(v1,sarkok[i][4],sarkok[i][0],sarkok[i][3],i);
        if(pontok.size()==0)
                        {tipus1=i;}
        pontok.clear();
        metszet(v2,sarkok[i][4],sarkok[i][0],sarkok[i][1],i);
        metszet(v2,sarkok[i][4],sarkok[i][1],sarkok[i][2],i);
        metszet(v2,sarkok[i][4],sarkok[i][3],sarkok[i][2],i);
        metszet(v2,sarkok[i][4],sarkok[i][0],sarkok[i][3],i);
        if(pontok.size()==0)
                        {tipus2=i;}
    }
    


    pontok.clear();
    for(int i=0;i<2;i++)
    {
        metszet(v1,v2,sarkok[i][0],sarkok[i][1],i);
        metszet(v1,v2,sarkok[i][1],sarkok[i][2],i);
        metszet(v1,v2,sarkok[i][3],sarkok[i][2],i);
        metszet(v1,v2,sarkok[i][0],sarkok[i][3],i);
    }


    float1 fazis=0;
    adat utolso;
    utolso.v1=v1;
    utolso.tipus=tipus1;
      float2 diff;
      
    
        
        if(pontok.size()>0)
        for(map<float1,adat>::iterator iter=pontok.begin(); iter!=pontok.end();++iter)
        {
            diff.x= iter->second.v1.x - utolso.v1.x;
            diff.y= iter->second.v1.y - utolso.v1.y;
    
            if(iter->second.tipus!=utolso.tipus ) fazis += hossz(diff)*k1;
            else                       
            {
                if(utolso.tipus==3) fazis += hossz(diff)*k1;
                else                fazis += hossz(diff)*k2;
            }

            utolso = iter->second;
        }
           diff.x= v2.x - utolso.v1.x;
           diff.y= v2.y - utolso.v1.y;
        if(tipus2!=utolso.tipus) fazis += hossz(diff)*k1;
        else           
        {
            if(tipus2==3) fazis += hossz(diff)*k1;
            else          fazis += hossz(diff)*k2;
        }

       
    visszater fazis;
}



int main()
{
 
dpy = XOpenDisplay(0);
win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0,0, 600, 600, 0,0,0);

XSelectInput(dpy, win, StructureNotifyMask);
XMapWindow(dpy, win);
gc = XCreateGC(dpy, win, 0, 0);

for(;;) { XEvent e; XNextEvent(dpy, &e); if (e.type == MapNotify) break; }



    sarkok[0][0]=float2(210,250);
    sarkok[0][1]=float2(390,250);
    sarkok[0][2]=float2(400,310);
    sarkok[0][3]=float2(200,310);

    sarkok[0][4].x=(sarkok[0][0].x+sarkok[0][1].x+sarkok[0][2].x+sarkok[0][3].x)/4.0;
    sarkok[0][4].y=(sarkok[0][0].y+sarkok[0][1].y+sarkok[0][2].y+sarkok[0][3].y)/4.0;
    
    
    sarkok[1][0]=float2(300,180);
    sarkok[1][1]=float2(400,180);
    sarkok[1][2]=float2(390,240);
    sarkok[1][3]=float2(310,240);

    sarkok[1][4].x=(sarkok[1][0].x+sarkok[1][1].x+sarkok[1][2].x+sarkok[1][3].x)/4.0;
    sarkok[1][4].y=(sarkok[1][0].y+sarkok[1][1].y+sarkok[1][2].y+sarkok[1][3].y)/4.0;
    


    float2 tmp;
    float2 forras(150,310);
    float2    cel(450,200);



int s=2,g=40;
for(int y=g;y<500-g;y+=s)
for(int x=g;x<500-g;x+=s)
{
    float2 amplitudo(0,0);
    float1
        k1=M_PI*2.0/(0.1),
        k2=M_PI*2.0/(0.12);
    float1 fazis=0;
    float2 kep(x,y);

    
    int u=0;
 
     for(int x3=-40;x3<41;x3++)
    {
        kep.x=x+0.5*(frand(2.0)-1.0);            
        kep.y=y+0.5*(frand(2.0)-1.0);

        fazis =  calc(forras,kep, k1,k2);
        fazis += calc(kep,cel,    k1,k2);

        amplitudo.x += cos(fazis);
        amplitudo.y += sin(fazis);
        u++;
    }

    amplitudo.x/=(float1)u;
    amplitudo.y/=(float1)u;
    
    float1 P=skalar(amplitudo,amplitudo);
    int szin=(int)(P*P*255);
    if(belul(float2(x,y)))
    {
        szin<<=16;
        szin|=0x002000;
    }
    
    for(int y2=0;y2<s;y2+=1)
    for(int x2=0;x2<s;x2+=1)
        pont(x+x2,y+y2,szin);
}


vonal(forras.x,forras.y-5,forras.x,forras.y+5,0xffffff);
vonal(forras.x-5,forras.y,forras.x+5,forras.y,0xffffff);
vonal(cel.x,cel.y-5,cel.x,cel.y+5,0xffffff);
vonal(cel.x-5,cel.y,cel.x+5,cel.y,0xffffff);


XFlush(dpy);
getchar();

return 0;
}

Előzmény: Aparadox (813)
sat3 Creative Commons License 2012.09.08 0 0 826

*elérni

helyett bejarni

Előzmény: sat3 (825)
sat3 Creative Commons License 2012.09.08 0 0 825

Feynman eljárása pontosan megadja, hogy a két fehér kereszt közti utat hogy tudja a foton optimális idő alatt elérni, Ha változtatom a közegbeli hullámhosszt, megváltozik az út.

 

Na ennyi az egész. Kicsit jobb, mint a te móricka-rajzod. xD

 

Előzmény: sat3 (824)
sat3 Creative Commons License 2012.09.08 0 0 824

Tessék. Egyébként jó szrul választottad meg a szögeket. Majdnem merőlegesen esik be a fény, úgy meg nem törik meg.

Gratulálok az óriási geometriai tudásodhoz.

 

És ez még mindig csak egy egyszerűsített eljárás. Ezért nem tökéletes az eredmény,

 

 

 

//g++ x.cpp -lX11


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <X11/Xlib.h>


#include <map>
using namespace std;


#define igaz true
#define hamis false
#define visszater return



Display *dpy;
Window win;
GC gc;

void pont(int x,int y,int szin)
{
    XSetForeground(dpy,gc,szin);
    XDrawPoint(dpy, win, gc, x,y);
}
void vonal(int x1,int y1,int x2,int y2,int szin)
{
    XSetForeground(dpy,gc,szin);
    XDrawLine(dpy, win, gc, x1,y1, x2,y2);
}


#define gyok sqrt



struct float2
{
float x,y;

float2() {x=y=0;};
float2(float x2,float y2) {x=x2;y=y2;}
};

float skalar(float2 v1,float2 v2) { return (v1.x*v2.x + v1.y*v2.y );}

float hossz(float2 v1) {return gyok(skalar(v1,v1));}

float2 normalt(float2 v1)
{
    float q=hossz(v1);
    v1.x/=q;
    v1.y/=q;
    visszater v1;
}





map<float,float2> pontok;

void metszet(float2 &v1,float2 &v2,float2 &u1,float2 &u2)
{
    float2 ir1,ir2, nor,tmp,metszespont;


    ir1.x=v2.x-v1.x;
    ir1.y=v2.y-v1.y;
    float h1=hossz(ir1);    
    ir1.x /= h1;
    ir1.y /= h1;
    
    ir2.x=u2.x-u1.x;
    ir2.y=u2.y-u1.y;
    float h2=hossz(ir2);    
    ir2.x /= h2;
    ir2.y /= h2;
    nor.x= ir2.y;
    nor.y=-ir2.x;    



    tmp.x=v1.x-u1.x;//u1
    tmp.y=v1.y-u1.y;
    float tav= (0.0- skalar(tmp,nor)) / skalar(ir1,nor);
    if(tav>=0.0)
    if(tav<=h1)
    {
        metszespont.x = v1.x + ir1.x*tav;
        metszespont.y = v1.y + ir1.y*tav;
        
        tmp.x = metszespont.x - u1.x;
        tmp.y = metszespont.y - u1.y;
        float tav2=skalar(tmp,ir2);
        
        if(tav2>=0.0)
        if(tav2<=h2)
        {
            pontok[tav]=metszespont;
        }
    }
}
float2 sarkok[2][5];

bool belul(float2 v1)
{
    for(int i=0;i<2;i++)
    {
        pontok.clear();
        metszet(v1,sarkok[i][4],sarkok[i][0],sarkok[i][1]);
        metszet(v1,sarkok[i][4],sarkok[i][1],sarkok[i][2]);
        metszet(v1,sarkok[i][4],sarkok[i][3],sarkok[i][2]);
        metszet(v1,sarkok[i][4],sarkok[i][0],sarkok[i][3]);
        if(pontok.size()==0)
                        visszater igaz;
    }
    visszater hamis;
}

float calc(float2 v1,float2 v2,float k1,float k2)
{
    int belul1=0,belul2=0;
    
    for(int i=0;i<2;i++)
    {
        pontok.clear();
        metszet(v1,sarkok[i][4],sarkok[i][0],sarkok[i][1]);
        metszet(v1,sarkok[i][4],sarkok[i][1],sarkok[i][2]);
        metszet(v1,sarkok[i][4],sarkok[i][3],sarkok[i][2]);
        metszet(v1,sarkok[i][4],sarkok[i][0],sarkok[i][3]);
        if(pontok.size()==0)
                        belul1|=1;
        pontok.clear();
        metszet(v2,sarkok[i][4],sarkok[i][0],sarkok[i][1]);
        metszet(v2,sarkok[i][4],sarkok[i][1],sarkok[i][2]);
        metszet(v2,sarkok[i][4],sarkok[i][3],sarkok[i][2]);
        metszet(v2,sarkok[i][4],sarkok[i][0],sarkok[i][3]);
        if(pontok.size()==0)
                        belul2|=1;
    }
    
    int masodik=0;
    pontok.clear();
    for(int i=0;i<2;i++)
    {
        metszet(v1,v2,sarkok[i][0],sarkok[i][1]);
        metszet(v1,v2,sarkok[i][1],sarkok[i][2]);
        metszet(v1,v2,sarkok[i][3],sarkok[i][2]);
        metszet(v1,v2,sarkok[i][0],sarkok[i][3]);
        
        masodik=pontok.size();
    }


    
    int szamlalo=1;
    float fazis=0;
    float2 utolso=v1;
      float2 diff;
      
    
        
        if(pontok.size()>0)
        for(map<float,float2>::iterator iter=pontok.begin(); iter!=pontok.end();++iter)
        {
            diff.x= iter->second.x - utolso.x;
            diff.y= iter->second.y - utolso.y;
    
            if(szamlalo==1&&belul1==0||masodik==szamlalo-1) fazis += hossz(diff)*k1;
            else                       fazis += hossz(diff)*k2;
            szamlalo++;
            utolso = iter->second;
        }
           diff.x= v2.x - utolso.x;
           diff.y= v2.y - utolso.y;
        if(belul2==0) fazis += hossz(diff)*k1;
        else           fazis += hossz(diff)*k2;

       
    visszater fazis;
}



int main()
{
 
dpy = XOpenDisplay(0);
win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0,0, 600, 600, 0,0,0);

XSelectInput(dpy, win, StructureNotifyMask);
XMapWindow(dpy, win);
gc = XCreateGC(dpy, win, 0, 0);

for(;;) { XEvent e; XNextEvent(dpy, &e); if (e.type == MapNotify) break; }



    sarkok[0][0]=float2(210,250);
    sarkok[0][1]=float2(390,250);
    sarkok[0][2]=float2(400,300);
    sarkok[0][3]=float2(200,300);

    sarkok[0][4].x=(sarkok[0][0].x+sarkok[0][1].x+sarkok[0][2].x+sarkok[0][3].x)/4.0;
    sarkok[0][4].y=(sarkok[0][0].y+sarkok[0][1].y+sarkok[0][2].y+sarkok[0][3].y)/4.0;
    
    
    sarkok[1][0]=float2(300,180);
    sarkok[1][1]=float2(400,180);
    sarkok[1][2]=float2(390,240);
    sarkok[1][3]=float2(310,240);

    sarkok[1][4].x=(sarkok[1][0].x+sarkok[1][1].x+sarkok[1][2].x+sarkok[1][3].x)/4.0;
    sarkok[1][4].y=(sarkok[1][0].y+sarkok[1][1].y+sarkok[1][2].y+sarkok[1][3].y)/4.0;
    


    float2 tmp;
    float2 forras(150,290);
    float2    cel(450,220);
    tmp.x = cel.x - forras.x;
    tmp.y = cel.y - forras.y;
    tmp=normalt(tmp);
    float q=tmp.x;tmp.x=tmp.y;tmp.y=-q;



int s=2,g=50;
for(int y=g;y<500-g;y+=s)
for(int x=g;x<500-g;x+=s)
{
    float2 amplitudo(0,0);
    float
        k1=M_PI*2.0/(0.1),
        k2=M_PI*2.0/(0.15);
    float fazis=0;
    float2 kep(x,y);

    
    int u=0;
 
     for(int x3=-10;x3<11;x3++)
    {
        kep.x=x+tmp.x*0.02*x3;            
        kep.y=y+tmp.y*0.02*x3;

        fazis =  calc(forras,kep, k1,k2);
        fazis += calc(cel,kep,    k1,k2);

        amplitudo.x += cos(fazis);
        amplitudo.y += sin(fazis);
        u++;
    }

    amplitudo.x/=(float)u;
    amplitudo.y/=(float)u;
    
    float P=skalar(amplitudo,amplitudo);
    int szin=(int)(P*P*255);
    if(belul(kep))
    {
        szin*=256*256;
        szin+=0x002000;
    }
    
    for(int y2=0;y2<s;y2+=1)
    for(int x2=0;x2<s;x2+=1)
        pont(x+x2,y+y2,szin);
}


vonal(forras.x,forras.y-5,forras.x,forras.y+5,0xffffff);
vonal(forras.x-5,forras.y,forras.x+5,forras.y,0xffffff);
vonal(cel.x,cel.y-5,cel.x,cel.y+5,0xffffff);
vonal(cel.x-5,cel.y,cel.x+5,cel.y,0xffffff);


XFlush(dpy);
getchar();

return 0;
}

Előzmény: Aparadox (810)

Ha kedveled azért, ha nem azért nyomj egy lájkot a Fórumért!