szimulációs módszerek : molekuláris dinamika (md)

Szimulációs Módszerek: Molekuláris Dinamika (MD)

4.év Mérnoki InformatikaBBTE Matematika és Informatika

Szimuláció – Molekuláris Dinamika

Molekuláris Dinamika szimuláció (MD)

meg akarjuk határozni a rendszert alkotó atomok, molekulák helyét (x,y,z) minden időpontban x(t), y(t), z(t)

Ehhez meg kell oldjam a mozgásegyenletet minden részecskére


A mozgásegyenlet általában a klasszikus Newton II. törvénye: f = ma ahol az f a részecskére ható összes erőt jelenti

ez függ a részecske helyzetétől de a többi részecske helyzetétől is – csatoltak az egyenletek, muszály egyszerre megoldani őket. Numerikusan, lépésről lépésre oldjuk meg őket

Szimuláció – Molekuláris DinamikaMinden lépésben

kiszámoljuk az összes erőt az összes részecskére (poziciókból, sebességektől)

elmozdítjuk az összes részecskét egyszerre

nullázzuk az erőket

Ismételjük ezt a lépést


Futás közben megkapjuk a részecskék pozicióját (x(t0),x(t1),x(t2),x(t3), …) – ebből a mikroszkopikus adatból bármit ki tudunk számolni ami a rendszerre jellemző (makroszkópikus jellemzőket is)

statisztikai számításokat végezhetünk futás közben utólagos feldolgozás közben


Az MD szimuláció megengedi hogy bármilyen mennyiséget kiszámoljunk, mert minden adat a rendelkezésünkre áll (hiszen minden egyes atom helyzetét tudjuk)

A kísérletekben nem minden adat áll rendelkezésre (pl az egyedi atomok poziciója nem, csak átlagolt, makroszkopikus mennyiségek mérhetők)


MD – KísérletekAzon mennyiségekkel amelyek mindkettőből kiszámolhatók(mérhetők), lehet ellenőrizni hogy mennyire jó a modell

Ha ezek a mennyiségek egyeznek, akkor az MD betekintést nyújthat olyan részletekbe amit másképp nem tudnánk tanulmányozni, megérthetünk mechanizmusokat, stb.


MD léptetésegy adott időpillanatban ismerjük x(t), v(t) és a(t)-t és meg akarjuk őket határozni egy későbbi t+dt időpontban: x(t+dt ), v(t+dt ) és a(t+dt) mivel a differenciál egyenletet helyettesítettük egy véges diffrenciákkal dolgozó egyenlettel, veszítünk a pontosságból. A jó léptető algoritmusok azok amelyek gyorsak és minél pontosabbak.


MD léptetés – Leapfrogxi = xi-1 + vi-(1/2) Δtai = f(xi)vi+(1/2) = vi-(1/2) + ai Δt


MD léptetés – LeapfrogEz a módszer O2 pontosságú, de nagyon stabil, időben reverzibilis(energiamegmaradás)

pl. harmonikus mozgásra nem vezet be szisztematikus hibát:


MD léptetés – Velocity Verlet algoritmusvi+1/2 = vi + ai Δt/2xi+1 = xi + vi+1/2 Δtai+1 = 1/m*f(xi+1)vi+1 = vi+1/2 + ai+1 Δt/2előnye, hogy adott úgy az x,a mint a v minden időpontban (ha a számolásokhoz kellett a sebesség, a leapfrog nem tartja meg ugyanabban az időpontban)


BD léptetés – Brownian Dynamics

A Brownian Dynamics egy egyszerűbb rendszert ír le: ebben a rendszerben nagyon nagyok a súrlódási erők, ezért minden mozgás csak az erők miatt történik, ha megszűnik az erő, azonnal lefékezik a mozgást a súrlódási erők.


Robert Brown Brown-mozgás


f+fs = ma ahol a súrlódási erő: fs = -ηva=0 (instant beáll a végső értékre)ηv = fηdx/dt = fdx =1/η f dt (x = x + f dt, η=1)

ez az egyenlet nem tartalmaz másodfokú differenciált, csak elsőfokút, egyszerűbb integrálni

Szimuláció – MD optimizáció

Hogyan tudjuk felgyorsítani az MD szimulációs kódunkat? Több trükk is létezik hozzá

Mielőtt optimizálnánk a kódot, jó megvizsgálni azt hogy melyik része az ami a legtöbb ideig fut, hol lehet a legtöbbet elérni a gyorsítással: profiling (gprof, cachegrind,valgrind)

a gprof a legegyszerűbb, leggyorsabb


Általában a legtöbb időt a kölcsönhatási potenciál számolása veszi el. Ez az a rész ami a legtöbbször végrehajódik és itt minden nyereség számít.

1000 részecske 1,000,000 időlépés~1012 számítás egy futattás során és ez egy kis rendszer. A mai processzoroknak ez nem olyan sok művelet


Ahhoz hogy megértsük azt hogy mi kerül sok időbe, meg kell érteni azt hogy egy program mikor processor bound és mikor memory bound

processor bound: a futási sebességét az határozza meg hogy milyen gyorsan tud a processzor műveleteket végezni: mindig minden adat kéznél van


memory bound: a futási sebességét az határozza meg hogy mikor tud a processzor az adathoz hozzáférni, a műveleteket sokkal gyorsabban el tudná végezni de az adat nincs kéznél, keresgélni kell a memóriában utána

Erre találták ki a cache-t, hogy lehetőleg ott legyen az adat azt elérni gyorsabb mint a memóriában keresgélni


A cache-nek különböző szintjei vannak, L1 level 1 cache a leggyorsabb és legkisebb, L2 nagyobb és lassúbb és így tovább

végrehajtás közben a processzor prediktál:

előrejelez


cache miss: ha az adat nincs benn a cache-ben akkor van egy cache miss azalatt az adatot keresgélik a memóriában

nagyon nem mindegy hogy hogyan van megírva a szimuláció, a kompiler nem érti a számítások logikáját, ezért a programozó kell optimálisan megírja a kódot


cache miss kivédése: ha lehet erre kell koncentrálni, legyen helyben az adat, ha az adat betöltődött a cache-be akkor dolgozzunk vele amennyit csak lehet

számítások csökkentése: ha nem rontjuk el vele a processor bound-ságot akkor ha lehet csökkentsük a számításokat


számítások csökkentése1.lépés Newton III. törvénye

felhasználhatjuk azt hogy a hatás és a ellenhatás ugyanakkora csak ellenkező előjelű – i és j részecskék között az erő fij=-fji ezt elég egyszer kiszámolni és mindkét részecskén tárolni. Ha a számítást végezzük rajtuk, már a cacheben vannak (ha jól tároljuk őket, azaz rendezve vannak)


számítások csökkentése2.lépés Erők tabulálása

mivel mindig ugyanazt a potenciált használjuk, ahelyett hogy behelyettesítsünk a képletbe minden egyes alkalommal egy r-et, előre kiszámolt r értékekre tabulálunk … sok apró lépésre felosztjuk a lehetséges r tartományt és egyer mindegyikre kiszámoljuk az f-et



jobb nem r hanem r2 függvényében tárolni és jobb nem f-et hanem f/r-et tárolni

nem mindig éri meg ezt a lépést megtenni, van amikor cache misshez vezet és olcsóbb lenne mindig újraszámolni (egyszerű képletek esetén)



dx = xi – xjdy = yi - yjdr2 = dx*dx + dy*dy ezért érdemes dr2 szerint tabulálnifx = f *dx/drfy = f* dy/dr ezért érdemes f/r-et tárolni


számítások csökkentése3.lépés Verlet szomszédsági lista

Ez az a csel amivel nagyon nagyon fel lehet gyorsítani a programot. Egy olyan potenciálunk kell legyen ami levágható. Ha ez teljesül akkor elérhetjük azt hogy sokkal kevesebb számolást végezzünk N2 ről Nlog(N)re lehet átmenni (futási idő függése a rendszer méretétől)



Ha mindenkit mindenkivel kölcsönhatásba léptetek, akkor N(N-1) számítást kell elvégezzek. Newton IIIal N(N-1)/2 –t.De igazán nem is kellene mindenkit mindenkivel állandóan kiszámoljak: megjegyezhetném kik vannak közel



Pl legyen egy 50x50-es doboz, 2000 részecske.Potenciál levágása: 4.0 távolságnál

Mindenki mindenkivel: 2000*1999/2 ~ 106

Csak akik szomszédok: 2000*ρ*πr2 ~80,000ρ=2000/(50*50)= 0.8 ; r = 4.0



A listát kicsit nagyobbra kellene csinálni mint amekkora a potenciál levágási határa, azért hogy ne kelljen minden lépésben újraszámolni kik a szomszédok (akkor nem csináltunk semmit)



Listaméret optimizálása: nagyobb lista – kevesebbszer kell újraépíteni de többet kell számolnikisebb lista - többször kell újraépíteni de kevesebbet kell számolni

pl. 1.5x a levágási határ jó kompromisszum sok esetben(kolloid rendszereknél ezt használom)



Mikor építsem újra a listát? Egyik lehetőség az hogy egy fix időlépés után. Ez nem annyira jó megoldás mert nem garantálja hogy minden rendben van – és potenciálisan túl gyakran fogom csinálni



Mikor építsem újra a listát? A másik lehetőség az hogy minden részecske számolja azt hogy mennyit mozdult el az utolsó frissítés óta, és ha eleget mozdult egyetlen részecske ahhoz hogy átmehetett volna a külső körből a belsőbe, akkor triggerel és újraépítjük a listát

ez az elmozdulás az utolsó lépés óta amúgy is ki van számolva a rendes léptetésnél


számítások csökkentése4.lépés Verlet szomszédsági cellák

Ahelyett hogy végigmenjek mind az N(N-1) lehetőségen a cellák újraépítésekor, minden részecskét hozzárendelek egy cellához. Ez könnyű, mert csak egy modulo osztás kell hozzá. Ezután a cellák segítségével kevesebb részecskével kell ellenőrizzek minden részecskét, hogy szomszédok-e



a nagy kör nem lehet több mint3 cellaméret



Minden cella egy láncolt listában tárolhatja azt hogy melyik részecskék vannak a cellában. A listák feje egy kétdimenziós pointer-lista, a next item pointer pedig minden részecskének lehet egy belső változója

Pinning site-oknál is lehet ezt alkalmazni, csak ott nem kell újraépíteni a listát, mivel a pinning siteok általában nem mozdulnak el


cache missek csökkentése5.lépés Térkitöltő görbék alkalmazása

A cache úgy prediktálja azt hogy milyen adatokra van szüksége a program futása közben, hogy amikor egy beolvasás történik, akkor nem egyetlen változót olvas be a memóriából, hanem a körülötte levő környezetet is beolvassa. Így ezek már a cache-ben lesznek egyetlen cache miss után



Egy egyszerű példának vegyünk egy mátrix szorzást. Nem mindegy az hogy sor vagy oszlop formájában tároljuk el az információt: ha sort olvasunk (első mátrix), akkor kevesebb cache miss-ünk lesz, ha oszlopot akkor minden elemnél van egy cache miss



Amikor egy elemet beolvas a memóriából,akkor beolvassa az előtte és utána levőelemeket is



A mi esetünkben minden részecske tartalmaz adott infomációkat (x,z,y koordináta, töltés, stb.) és mindig a szomszédos részecskék közötti kölcsönhatásokat számoljuk. Jó lenne hogyha azok a részecskék amelyek szomszédosak térben, a memóriában is szomszédosak lennének. Erre jó a térkitöltő görbe. Segítségével olyan indexeket kaphatunk, amelyekkel sorbarendeyhetjük a részecskéket, úgy, hogy a térben szomszédos részecskék a memóriában is szomszédosak legyenek.



Többfajta térkitöltő görbe létezik. Két gyakran használt görbe a Morton és a Hilbert görbék (ezek a görbék mind fraktálok). A Mortont lehet könnyebben kiterjeszteni 3D-re.

A térkitöltő görbe végtelen rendben kitölti a tér minden pontját. Mivel véges számú részecskénk van, csak egy adott rendig kell elmenni ahhoz hogy minden részecskének külön indexe legyen.



a görbe mentén generálhatunk indexeket amik alapjánrendezhetjük a vektorban a sorrendet

szimulációs módszerek : molekuláris dinamika (md)

Documents