Watson-Crick D0L rendszerek hálózatainak szimulációja

EÖTVÖS LORÁND TUDOMÁNYEGYETEM INFORMATIKAI KAR ALGORITMUSOK ÉS ALKALMAZÁSAIK TANSZÉK

Watson-Crick D0L rendszerek hálózatainak szimulációja

Témavezető:

Szerző:

Csuhaj Varjú Erzsébet

Ujvári Ádám

tanszékvezető egyetemi tanár

programtervező informatikus BSc,

ELTE IK

nappali tagozat

Algoritmusok és Alkalmazásaik Tanszék

Budapest, 2014

Tartalomjegyzék 1. Bevezető .............................................................................................................. 1 1.1 Feladat és annak értelmezése ........................................................................ 1 1.2 Definíciók és jelölések .................................................................................. 2 1.2.1 Általános jelölések ................................................................................. 2 1.2.2 A „trigger” .............................................................................................. 3 1.2.3 WD0L rendszerek hálózata .................................................................... 4 1.2.4 Fekete lyuk kommunikációs viselkedés ................................................. 5 1.2.5 NWD0L rendszer Watson-Crick útja ..................................................... 5 1.2.6 NWD0L rendszerek szópopulációja ....................................................... 6 1.3 Alkalmazott technológiákról ......................................................................... 7 1.3.1 A Java-ról röviden ...................................................................................... 7 1.3.2 JFreeChart .............................................................................................. 8 2. Felhasználói dokumentáció ................................................................................. 9 2.1 Bevezetés ....................................................................................................... 9 2.2 Rendszerkövetelmények ................................................................................ 9 2.2.1 Minimális rendszerkövetelmények......................................................... 9 2.2.2 Ajánlott rendszerkövetelmények .......................................................... 10 2.3 Telepítés ...................................................................................................... 11 2.4 Rendszerszintű jelölések ............................................................................. 11 2.4.1 Hálózatok ábécéjének jelölései ............................................................ 11 2.4.2 Hálózatok szavainak a megjelenítései .................................................. 12 2.5 Felhasználói felület paneljeinek bemutatása ............................................... 13 2.5.1 A grafikai felület áttekintése ................................................................ 13 2.5.2 Központi állapotpanel........................................................................... 14 2.5.2.1 Állapotmegjelenítő panel .................................................................. 14 2.5.2.2 Összehasonlító panel ......................................................................... 14

2.5.2.3 Szavak színkódolása .......................................................................... 15 2.5.2.4 Állapotmegjelenítő és Összehasonlító panel fejléce ......................... 17 2.5.3 Megfigyelő panel .................................................................................. 17 2.5.3.1 Megfigyelő panel felépítése .............................................................. 17 2.5.4 Hálózat tulajdonság szerkesztő panel ................................................... 19 2.6 Felhasználói felület eszköztárának és menüjének bemutatása .................... 22 2.6.1 Menüsáv ............................................................................................... 23 2.6.2 Eszköztár .............................................................................................. 26 2.7 Vezérlőpanel ................................................................................................ 27 2.7.1 Információs panel ................................................................................. 27 2.7.2 Számításvezérlő panel .......................................................................... 28 2.7.3 Léptetés művelet................................................................................... 29 2.7.4 Számítás művelet .................................................................................. 29 3. Fejlesztési dokumentáció .................................................................................. 32 3.1 Követelmények és megvalósítás ................................................................. 32 3.1.1 Követelmények ..................................................................................... 32 3.1.2 Megvalósítás folyamata ........................................................................ 33 3.1.3 Használt fejlesztő eszköz...................................................................... 35 3.1.4 Használt külső függvénykönyvtár ........................................................ 35 3.2 Főbb használati esetek ................................................................................. 35 3.3 Hálózat tulajdonság fájlok ........................................................................... 37 3.3.1 Hálózat struktúra fájl ............................................................................ 37 3.3.2 Hálózat állapot fájl ............................................................................... 38 3.4 Osztályok leírása ......................................................................................... 40 3.4.1 Bevezetés .............................................................................................. 40 3.4.2 Logikai osztályok ................................................................................. 40 3.4.2.1 Logikai osztályok áttekintése ............................................................ 40

3.4.2.2 Az „NWSystemLogic” osztály .......................................................... 41 3.4.2.3 Az „NWFileManager” osztály .......................................................... 43 3.4.2.4 Az „NWDisplayManager” osztály .................................................... 44 3.4.2.5 Az „NWAxiomMaskManager” osztály............................................. 46 3.4.2.6 A „Gyár” osztályok ........................................................................... 47 3.4.2.7 Az „NWNetwork” osztály ................................................................. 48 3.4.2.8 Az „NWTrigger” osztály ................................................................... 49 3.4.2.9 Az „NWNode” osztály ...................................................................... 50 3.4.2.10 Az adat struktúra osztályok ............................................................. 51 3.4.3 Grafikai osztályok ................................................................................ 52 3.4.3.1 Grafikai osztályok áttekintése ........................................................... 52 3.4.3.2 Az „NWFrame” osztály..................................................................... 53 3.4.3.3 Az „NWGuiBuilder” osztály ............................................................. 55 3.4.3.4 A „Központi állapotmegjelenítő” panelek ........................................ 56 3.4.3.5 Az „NWStatusBar” és a hozzá tartozó osztályok .............................. 59 3.4.3.6 Az „NWObserverPanel” és részei ..................................................... 61 3.4.3.7 Az „NWPropertyEditor” és részei ..................................................... 64 3.4.3.8 Az „NWComputation” osztály és részei ........................................... 66 3.4.3.9 Az „NWStringPopulationLineChart” osztály ................................... 69 3.4.3.10 Az „NWAboutDialog” osztály ........................................................ 69 3.5 Tesztelés ...................................................................................................... 70 3.5.1 Tesztelés használatai esetek alapján ..................................................... 70 3.5.2 Strukturális tesztelés ............................................................................. 72 4. Összegzés .......................................................................................................... 75 Irodalomjegyzék ............................................................................................ 76

1. Bevezető 1.1 Feladat és annak értelmezése Leonard Adleman azzal, hogy 1994-ben DNS szálak használatával meghatározta, hogy van-e Hamilton-út egy adott hét csúcsú gráfban [1], megmutatta, hogy a molekuláris biológia alkalmazásai felhasználhatóak bonyolult számítási problémák megoldására. Azóta a „DNS számítás” iránti érdeklődés fokozottan növekszik. Arról, hogy a DNS számítás a formális nyelvek elméletének szempontjából is számottevő, megerősítést nyerhetünk [2] által. A

DNS

egy

meghatározó

tulajdonsága

az

úgynevezett

Watson-Crick

komplementaritás, mely szerint a DNS-t alkotó bázisok párokba rendezhetők a DNS láncban való előfordulásuk alapján, ugyanis minden bázissal szemben, a DNS kettős spirál másik ágában csak egy bizonyos bázis szerepelhet. Ezen tulajdonság elve szolgál az [5, 6]-ban bemutatott Watson-Crick D0L rendszerek hálózata nevű számítási modell alapjául. Ebben a szavak felett értelmezett formális újraíró mechanizmusban D0L rendszerek – a legegyszerűbb és legszélesebb körben tanulmányozott Lindenmayer rendszerek – összefüggő gráfként összekötött hálózata alkotja magát a számítási modellt. Ezekben a DNS-szerű ábécé felett értelmezett rendszerekben egy előre definiált feltétel szerint osztályozzuk az átírt szavakat, és ha egy szó nem felel meg a feltételnek – vagyis a szó a rendszer szerint „hibás”–, akkor a szó komplemense „nem hibás” és a számítás ezen a szón folytatódik tovább. A Watson-Crick D0L rendszerek hálózatának az alapötlete az, hogy a számítás vagy a fejlődés közben, ha valami meghibásodik, akkor a meghibásodott szó komplemensén folytathatjuk tovább a számítást, amelyet mindig ismerünk, és sohasem hibás. A Watson-Crick komplementaritásra mint műveletre tekintünk, amely művelet minden szóhoz a szó komplemensét rendeli [3]. A Watson-Crick D0L rendszerek több érdekes – tanulmányozásra érdemes – kérdést is felvetnek, mint például a rendszer stabilitása, a periodicitása, a generált nyelvek egyezése, vagy a rendszerek növekedési üteme. Ezen újraíró mechanizmusok

1

számítási ereje is egy kiváltképpen fontos kérdés; bármely Turing-kiszámítható függvény kiszámítható Watson-Crick Lindenmayer rendszerrel is [4]. Bár a Watson-Crick D0L rendszerek hálózata a DNS számítás területéhez tartozik, jelentősége túlnő azon, hiszen olyan osztott rendszerek modelljének tekinthető, ahol a kommunikációt a feldolgozandó adat hibás vagy nem hibás volta vezényli. A szakdolgozat fő célja egy olyan szoftver létrehozása, mely ilyen rendszerek hálózatainak a működését modellezi, és amely egyszerű felhasználói felülete valamint rendszerezett és átlátható kimeneti adatai lévén alkalmas lehet ezen matematikai modellek viselkedésnek a tanulmányozására. Célunk, hogy a Watson-Crick D0L rendszerek ilyenfajta szimulációja által jobban megismerhessük azok működését, hogy újabb következtetéseket tudjunk levonni, miközben akár új, eddig fel nem merült kérdések felbukkanására is számítunk. 1.2 Definíciók és jelölések A következőkben [5] alapján felidézzük a fontosabb fogalmakat és definíciókat a Watson-Crick D0L rendszerekkel és azok hálózataival kapcsolatban. 1.2.1 Általános jelölések Nem üres szavak egy halmazát ∑ ábécé felett jelölje ∑ +, ha ebben a halmazban megtalálható a λ üres szó, akkor a ∑* jelölést használjuk. Ha szavak egy halmaza L⊆∑*, akkor azt mondjuk, hogy L nyelv ∑ felett. Egy ω ∈ L, L⊆∑* szónak a hosszát jelölje |ω|, szavak egy U⊆∑ halmazára jelölje |ω|U az U halmaz betűinek a számát az ω szóban. Egy véges L nyelvre az L-ben található szavak számát jelöli card(L). D0L rendszer alatt egy H = ( ∑, g, ω0 ) hármas értünk, ahol ∑ egy ábécé, g egy endomorfizmus ∑* felett, és ω0 ∈ ∑* az axióma. Az S(H) szósorozat, szavak egy ω1, ω2, ω3, … sorozatát jelenti, ahol ωi+1 = g(ωi) minden i > 0-ra. Egy ∑ DNS-szerű ábécé alatt egy olyan ábécét értünk, amely mérete 2n, ahol n ≥ 1, és ∑ = { a1, …, an, ā1, …, ān }. Az ai és āi betűket komplemens betűknek nevezzük, továbbá a nem felülhúzott betűk neve „purin”, a felülhúzott betűk neve pedig „pirimidin”. Ez a terminológia a DNS-t alkotó bázisok elnevezéséből (adenin, guanin,

2

citozin, timin) ered, mely ábécéként reprezentálva {A, C, T, G}, ahol az A és G betűk purinok, a C és T betűk pedig pirimidinek. Jelöljük hω jelöléssel az endomorfizmust, amely egy ∑ DNS-szerű ábécé felett minden betűhöz a komplemens betűpárját rendeli. hω egy másik elnevezése WatsonCrick morfizmus. Egy Watson-Crick D0L rendszer (vagy röviden WD0L rendszer) egy W = ( H, ϕ ) pár, ahol H = ( ∑, g, ω0 ) egy D0L rendszer, ∑ DNS-szerű ábécével, g morfizmussal, és ω0 ∈ ∑+

axiómával.

ϕ:

∑*

→

{0,

1}

egy

leképezés,

ahol

ϕ (ω0) = ϕ (λ) = 0 és minden u ∈ ∑ * szóra, amire igaz, hogy ϕ (u) = 1, arra ϕ (hω(u)) = 0 teljesül. Egy W Watson-Crick D0L rendszer S(W) szósorozatára, amely tartalmazza az (ω1, ω2, ω3, … ) szavakat igaz az, hogy ωi+1 =

𝑔 ωi ℎ𝜔 𝑔 ωi

ℎ𝑎𝑐𝑠𝑎𝑘 𝜙 𝑔 ωi

=0

ℎ𝑎𝑐𝑠𝑎𝑘 𝜙(𝑔 ωi = 1

ahol (i > 0). Mondhatjuk azt is, hogy ωi -ből közvetlenül következik ωi+1 W-ben; ekkor használhatjuk az ω𝑖

ω𝑖+1 jelölést. Az ω𝑖

ω𝑖+1 (i > 0) levezetési lépések

sorozatát számításnak nevezzük W-ben. A továbbiakban egy ω ∈ ∑* szót „helyesnek” mondunk ϕ szerint, ha ϕ (ω) = 0, egyébként „hibásnak” nevezzük [5]. 1.2.2 A „trigger” A komplemens átírásban a ϕ (u) = 1 feltétel neve: „trigger”. Nyilvánvalóan többféle ϕ leképezés teljesítheti a komplemens átírási trigger definíciójának a feltételeit. A továbbiakban bemutatásra kerülő trigger típust „Standard triggernek” nevezünk. Standard trigger esetén egy ω szó kielégíti a trigger komplemens átírásra vonatkozó feltételét (másképpen fogalmazva a szó „hibás), ha a szó betűi között nagyobb számban találhatóak meg pirimidinek (fölülhúzott betűk), mint purinok (nem fölülhúzott betűk). Formálisan, tekintsünk egy DNS-szerű ∑ = { a1,

…,

an, ā1,

…,

ān }, n > 1 ábécét.

Legyen ∑PUR = { a1, …, an }és ∑PYR = { ā1, …, ān }. Ekkor a következőképpen definiáljuk a ϕ: ∑* → {0, 1} leképezést: egy ω ∈ ∑* szóra 3

ϕ (ω) =

0 ℎ𝑎 |ω|∑ PUR ≥ |ω|∑ PYR é𝑠 1 ℎ𝑎 |ω|∑ PUR < |ω|∑ PYR

Legyen W = ( H, ϕ ) egy Watson-Crick D0L rendszer, ahol H = ( ∑, g, ω0 ). W Watson-Crick útján egy α bináris szót értünk {0, 1} fölött, ahol az α szó i-edik bitje 1, akkor és csak akkor, ha az i-edik számítási lépésben komplemens átfordulás történt, vagyis, ha ϕ (ωi-1) = 1 [5]. 1.2.3 WD0L rendszerek hálózata Watson-Crick D0L rendszerek hálózata (vagy röviden NWD0L rendszer) alatt WD0L rendszerek egy olyan együttesét értjük, amelyben minden WD0L rendszer azonos ábécével és triggerrel szinkronizált módon végzi a saját szóhalmazán a szavak átírását, és minden számítási lépés befejeztével az átírt szavak egy részének (akár mindegyik szónak) a példányát elküldi a hálózat összes többi WD0L tagjának. Formálisan egy NrWD0L rendszer r darab komponenssel, vagy csúccsal (ahol r > 0 ) a következőt jelenti: Γ = ( ∑, ϕ, (g1, {A1}), …, (gr, {Ar})), ahol 

∑ = { a1, …, an, ā1, …, ān }, n > 0, egy DNS-szerű ábécé, a rendszer ábécéje,



ϕ: ∑* → {0, 1} leképezés a rendszer triggere,



(gi, {Ai}) 1 ≤ i ≤ r, az i-edik komponense, vagy az i-edik csúcsa a Γ rendszernek. gi a D0L rendszer morfizmusa ∑ felett, Ai pedig egy ϕ szerint helyes nem üres axióma ∑ felett, a i-edik komponens kezdőaxiómája.

Egy Γ = ( ∑, ϕ, (g1, {A1}), …, (gr, {Ar})) NWD0L rendszer állapota alatt az (L1, …, Lr) r-est értjük, ahol Li 1 ≤ i ≤ r helyes szavak egy véges halmaza, az i-edik komponens állapota. ({A1}, …, {Ar}) a Γ hálózat kezdeti állapota. Ezeknek a matematikai modelleknek az általunk készített programbeli megfelelőjét a 2. és 3. pontban „hálózatoknak” nevezzük. Legyen s1 = (L1, …, Lr) és s2 = (L’1, …, L’r) két állapota a Γ = ( ∑, ϕ, (g1, {A1}), …, (gr, {Ar})) r ≥ 1 NWD0L rendszernek. 

Azt mondjuk, hogy s1-ből közvetlenül levezethető s2 az (a) protokoll szerint (jelölés: 𝑠1

𝑎

𝑠2 ), ha 𝐿′𝑖 = 𝐶𝑖′

𝑟 ′ 𝑗 =1 ℎω (𝐵𝑗 )

, ahol

4



𝐶𝑖′ = 𝑔𝑖 𝑣 𝑣 ∈ 𝐿𝑖 , ϕ g i v

= 0} és

𝐵𝑗′ = 𝑔𝑗 𝑢 𝑢 ∈ 𝐿𝑗 , ϕ g j u

= 1}.

Azt mondjuk, hogy s1-ből közvetlenül levezethető s2 a (b) protokoll szerint (jelölés: 𝑠1

𝑏

𝑠2 ), ha 𝐿′𝑖 = ℎω 𝐵𝑖′

𝑟 ′ 𝑗 =1 𝐶𝑗

𝐵𝑖′ = 𝑔𝑖 𝑢 𝑢 ∈ 𝐿𝑖 , ϕ g i u

= 1} és

𝐶𝑗′ = 𝑔𝑗 𝑣 𝑣 ∈ 𝐿𝑗 , ϕ g j v

= 0} igaz.

, ahol

A két protokoll esetén a levezetési lépés után a hálózat minden WD0L rendszer csúcsa a helyes és a „javított” (egy „hibás” szó komplemense) axiómák közül protokolltól függően kommunikál szavakat a többi csúccsal. Protokoll (a) esetén a csúcs minden „javított” szóról küld egy másolatot a többi csúcsnak, míg protokoll (b) esetén minden helyes szó másolatát küldi el a komponens a többi csúcsnak. Legyen a Γ = ( ∑, ϕ, (g1, {A1}), …, (gr, {Ar})) r ≥ 1 egy NWD0L rendszer, amely az (x) protokollt használja, ahol x∈ {a, b}. Az NWD0L rendszer állapot sorozata egy S( Γ ) sorozat, ahol S( Γ ) = s(0), s(1), … , és s(0) = ({A1}, …, {Ar}) és s(t)

𝑥

s(t+1)

minden t ≥ 0-ra [5]. 1.2.4 Fekete lyuk kommunikációs viselkedés Legyen a Γ = ( ∑, ϕ, (g1, {A1}), …, (gr, {Ar})) r ≥ 1 egy NWD0L rendszer, amely az (x) protokollt használja, ahol x∈ {a, b} és legyen s(t) = (L1(t), …, Lr(t)) a t-edik számítási lépés állapota, ahol t ≥ 0. Azt mondjuk, hogy a rendszer i-edik komponense fekete lyuk, 1 ≤ i ≤ r, ha minden t ≥ 0-ra igaz, hogy: 1. ha x = a, akkor gi(Li(t)) helyes ∑ fölötti szavakat tartalmaz ϕ szerint, és 2. ha x = b, akkor gi(Li(t)) „hibás” ∑ fölötti szavakat tartalmaz ϕ szerint [5]. 1.2.5 NWD0L rendszer Watson-Crick útja Legyen a Γ = ( ∑, ϕ, (g1, {A1}), …, (gr, {Ar})) r ≥ 1 egy NWD0L rendszer, amely az (x) protokollt használja, ahol x∈ {a, b} és legyen S( Γ ) = s(0), s(1), …a Γ rendszer állapot sorozata. 

A Γ rendszerhez tartozó Watson-Crick út alatt egy olyan szót értünk bináris {0, 1} ábécé felett, ahol a szó i-edik bitje 1 akkor és csak akkor, ha 5

a számítási lépések során s(i – 1)

𝑥

s(i), i ≥ 1 teljesül, hogy legalább egy

csúcs kommunikációra kijelöl legalább egy szót az állapothalmazából, és annak egy példányát (másolatát) elküldi a többi komponensnek. Ha r = 1, akkor (a) protokoll esetén komplemens átírás, (b) protokoll esetén pedig komplemens átírás hiánya esetén 1 az i-edik bit. 

A Γ rendszer egy j komponenséhez tartozó Watson-Crick út alatt egy olyan szót értünk bináris {0, 1} ábécé felett, ahol a szó i-edik bitje 1 akkor és csak akkor, ha a számítási lépések során s(i – 1)

𝑥

s(i), i ≥ 1 teljesül,

hogy a j-edik komponens kommunikációra kijelöl legalább egy szót az állapothalmazából, és annak egy példányát (másolatát), elküldi a többi csúcsnak [5]. 1.2.6 NWD0L rendszerek szópopulációja Legyen a Γ = ( ∑, ϕ, (g1, {A1}), …, (gr, {Ar})) r ≥ 1 egy tetszőleges NWD0L rendszer, amely az (x) protokollt használja, ahol x∈ {a, b}. Legyen s(t) = (L1(t), …, Lr(t)), t = 0, 1, 2, …, a rendszer állapota a t-edik lépésben. Ekkor definiálunk egy p: N → N függvényt úgy, hogy 𝑝 𝑡 = ∑𝑟𝑖=1 𝑐𝑎𝑟𝑑(𝐿𝑖 (t)) , t ≥ 0. A p függvényt a Γ rendszer szópopuláció növekedési függvényének nevezzük. A pi : N → N függvény az i-edik csúcs szópopuláció növekedési függvénye ( 1 ≤ i ≤ r), ahol pi(t) = card(Li(t)), t = 0, 1, 2, … [5].

6

1.3 Alkalmazott technológiákról 1.3.1 A Java-ról röviden A következőkben [7] alapján röviden összefoglaljuk a Java programozási nyelv jellegzetességeit. A Java egy általános célú, objektumorientált programozási nyelv, melyet 2009-ig a Sun Microsystems fejlesztett, 2009-től pedig az Oracle. A szakdolgozat által is használt Java 1.7 már az Oracle gondozásában lett kiadva 2011-ben. A Java szinte mindenütt megtalálható mindennapjainkban, nem csak számítógépünkön, de a mobil eszközöktől kezdve a banki rendszereken át egészen a minden háztartásban megtalálható mosógépig. Hihetetlen népszerűségét a különböző rendszerek között való könnyű átültethetőségének és magas fokú biztonságának köszönheti.

1. ábra: Java

A Java szoftver három fontos szerepet tölt be: 

programozási nyelv



köztes réteg (middleware)



platform A Java legfontosabb része a Java virtuális gép, vagyis a JVM. A JVM rengeteg

féle berendezésben, és szoftvercsomagban jelen van, így köztes rétegként és platformként is működik egyaránt. A nyelv „platform független”, ami azt jelenti, hogy

7

egy adott platformra fejlesztett program minimális változtatások után egy másik platformon is ugyanúgy futni fog [7].

1.3.2 JFreeChart Jelen program egyik fontos jellemvonása, hogy a megadott Watson-Crick D0L rendszerek hálózatainak az állapotait szemlélteti és elemzi. Mivel ezen rendszerek állapotaiban a szavak számának az iterációk során való növekedési üteme – vagy bizonyos esetekben csökkenési üteme – egy fontos szempont lehet kutatásaink során, ezért a program – többek között – egy diagramon szemlélteti a kérdéses hálózatok szópopulációjának az alakulását. A diagram programbeli megvalósítására a JFreeChart nyílt forrású Java keretrendszer lett felhasználva. A JFreeChart project fejlesztése 2000 februárjában indult, és mára a legszélesebb körben használt Java függvénykönyvtárrá nőtte ki magát. Ez a keretrendszer egyszerű és rugalmas lehetőséget kínál interaktív és nem interaktív diagramok és grafikonok létrehozásához valamint azoknak a szemléltetéséhez [8]. A szakdolgozat ezeknek a lehetőségek egy kisebb szegmensét használja fel: a kétdimenziós, színes és nem interaktív vonal grafikonokat. Erről a lehetőségről bővebben a 2.6.2 pontban olvashatunk.

8

2. Felhasználói dokumentáció 2.1 Bevezetés A

felhasználói

dokumentáció

három

logikai

részből

áll;

az

első

a

rendszerkövetelményeket, a második a telepítést, a pedig harmadik a program kezelését hivatott bemutatni. 2.2 Rendszerkövetelmények 2.2.1 Minimális rendszerkövetelmények Mivel a szoftver Java programnyelv használatával készült, a futtatásához elengedhetetlen, hogy a felhasználó számítógén telepítve legyen a Java Runtime Enviroment szoftver legfrissebb, hetedik verziója (továbbiakban JRE 7). Mivel ez a futtatási környezet elérhető a legtöbb széles körben elterjedt operációs rendszerre, ezért több platformon is használható program. Az alábbi operációs rendszerekhez elérhető el a Java JRE 7: Windows:[9] 

Windows 8



Windows 7



Windows Vista SP2



Windows XP SP3 (32-bit); Windows XP SP2 (64-bit)



Windows Server 2008



Windows Server 2012 (64-bit)

Mac OS X: [9] 

Mac OS X 10.7.3 (Lion) vagy újabb

Linux: [9] 

Suse Linux Enterprise Server 10 SP2, 11.x



Ubuntu Linux 10.04 vagy újabb



Redhat Enterprise Linux 5.5+; 6.x 9



Oracle Linux 5.5+; 6.x

Hardverkövetelmények tekintetében a Java JRE 7 futtatásához szükséges minimumot kell teljesítenie a szoftver futtatására szánt számítógépnek, mivel azonban a program főbb funkciói viszonylag nagy számításigénnyel rendelkeznek, ezért ajánlott egy minimum szintet teljesítő számítógépnél nagyobb memória és processzor teljesítményű rendszer beüzemelése. A Java JRE 7 minimum hardverkövetelménye operációs rendszerekre bontva a következő: Operációs rendszer

Memória

Lemezterület

Windows

128 MB RAM

124 MB HDD

Mac OS X

128 MB RAM

124 MB HDD

Linux

58 MB RAM

64 MB HDD

1. táblázat: minimum hardverkövetelmények [9]

2.2.2 Ajánlott rendszerkövetelmények A rendszer tökéletes működéséhez a legelterjedtebb operációs rendszer, a Windows szükséges. Követelmény továbbá a szélesvásznú 16:9-es képátlóval rendelkező monitor, és a legalább 1366x768-as felbontás, melyre a grafikus felület elrendezésének a megfontolásai miatt van szükség. A szoftver fejlesztése és tesztelése az alábbi ajánlott konfiguráción történt: 

Intel Core™ i3-2370M 2.40GHz processzor



4 GB DDR3 RAM



Windows 7 64-bit operációs rendszer

10

SSD háttértár használata nagyban megnöveli a program számítási teljesítményét az input-output műveletek sebességének nagymértékű növekedése miatt, hiszen a számítás állapotának fájlba mentése sokkal gyorsabban történik meg. 2.3 Telepítés Abból fakadóan, hogy a program Java alkalmazás, a futtatáshoz elegendő, ha a megfelelő Java futtatási környezet telepítéséről gondoskodunk, ezen felül más program telepítésére nincs szükség. A

Java

virtuális

gép

telepítője

az

alábbi

címről

tölthető

le:

http://www.oracle.com/technetwork/java/javase/downloads/jre7downloads-1880261.html

Miután meggyőződtünk arról, hogy támogatott operációs rendszert használunk, fogadjuk el licencszerződést és töltsük le a megfelelő JRE 7 telepítő fájlt. Ha frissíteni szeretnénk a Java futtatási környezetünket, telepítés előtt távolítsuk el a régi verziót. Miután feltelepítettük a futtatási környezetet, rendszerünk készen áll a szoftver futtatására, ami a program könyvtárában található NwdolSystem.jar fájl elindításával lehetséges. 2.4 Rendszerszintű jelölések 2.4.1 Hálózatok ábécéjének jelölései A program saját jelölést használ a felhasználó által megadott hálózatok állapotainak a megjelenítésére, és a hálózatok morfizmusainak szabályaira is. A rendszerben megjelenő állapotok elemei és a morfizmus szabályok olyan szavakból állnak, melyek az 1.2 pontban bemutatott speciális DNS-szerű ábécé betűiből épülnek fel. Ezen ábécék legfontosabb sajátossága, hogy páros számú betűből állnak, és a betűket logikailag két jól elkülöníthető halmazba lehet sorolni úgy, hogy mindkét halmaz minden elemére igaz, hogy a másik halmazban megtalálható hozzá egy komplemens betű, és ha x betű komplemense y, akkor y betű komplemense x, ahol x és y különböző logikai halmazba tartozó betűi az ábécének.

11

Az egyik logikai halmaz elemeit „purinoknak” hívjuk, míg másik halmaz elemeit „pirimidineknek”. A programban használt hálózatok ábécéjében minden „purin” a betűvel kezdődik, és egy számmal folytatódik, ami az ábécé adott elemének az indexe. A „pirimidin” elemek b betűvel kezdődnek és szintén számmal folytatódnak, ahol a betű után következő szám megegyezik az adott elemhez tartozó „purin” komplemens pár indexével. Könnyű észrevenni, hogy így a legmagasabb indexű betű indexe az ábécé méretének a fele. Példaként tekintsük az alábbi ábécét: 

Ábécé mérete: 6.



Mivel két egyenlő logikai halmazra osztja az ábécé betűit a WatsonCrick komplementaritás, ezért a „purinok” száma 3, és a „pirimidinek” száma is 3.



A purinok egytől indexelve a következők: a1, a2 és a3.



A pirimidinek szintén egytől indexelve a következők: b1, b2 és b3.



Ekkor komplemens párt alkotnak az (a1, b1), az (a2, b2) és az (a3, b3) párok.

2.4.2 Hálózatok szavainak a megjelenítései A program két különböző módon jeleníti meg az hálózat szavait. Az első megjelenítési mód a „nem összevont megjelenítés”, mely szerint minden szó az azt felépítő betűk egymás mellé helyezett sorozatából épül fel, és a betűk szóközzel vannak elválasztva. Így vannak jelölve a hálózati morfizmusok szabályai, és ez a szintaxisa az új hálózat létrehozása vagy módosítása input mezőkbe megadandó adatoknak is, melyről bővebb információ található a 2.5.4 pontban. A második megjelenítési mód az „összevont megjelenítés”, mellyel egy adott iterációban megjelenő szavakat szemlélteti a rendszer. Ezen jelölés szerint, ha egy szóban található olyan részszó, ami azonos betűk sorozatából áll, akkor a sorozat lecserélődik egy olyan részszóra, melynek a betűsorozat első eleme az első betűje, ezt követi egy „^” karakter, a részszó végén pedig a betű sorozat elemszáma áll. Az alábbi példa szemlélteti a két megjelenítési módszer közötti különbséget egy adott szón: 12



„nem összevont”: a1 a2 a2 a2 b2 b2 b2 b2 a3 b3 b3



„összevont”: a1 a2^3 b2^4 a3 b3^2 Az „összevont megjelenítésre” azért van szükség, mert a rendszer működése

során nem ritka az olyan szó, melyben akár több ezer azonos betű áll egymás mellett, és a betűk ilyen fajta összevonása nélkül emberi szemmel lehetetlen lenne figyelemmel kísérni az állapotok elemeinek a változásait.

2.5 Felhasználói felület paneljeinek bemutatása 2.5.1 A grafikai felület áttekintése A szoftver az áttekinthetőség és könnyű kezelhetőség jegyében négy logikai részre lett osztva. A 2. ábrán látható a program indítás utáni felülete, melyen a színes keretek mutatják ezeket a részeket.

2. ábra: felhasználói felület, indítás után

A programablak felső részén piros színnel jelölt panel a menüt, az eszköztárat és a „Rendszerinformációs sávot” foglalja magába, itt lehet az elérhető funkciók nagy 13

részét kiválasztani, a „Rendszerinformációs sáv” pedig a legutóbb végrehajtott művelet sikerességéről vagy sikertelenségéről, illetve a művelet eredményének részleteiről tájékoztat. Alul sárga keretben látható a hálózatok „Léptetését” – vagyis előző vagy következő iteráció betöltését – és „Számítását” indító gomboknak és bemeneti mezőknek helyet adó „Vezérlő panel”, melyen a kiválasztott és az összehasonlított hálózatok számított és betöltött iteráció számáról is tájékoztat a rendszer. Kék színnel jelölve a képernyő jobb oldalán található a „Megfigyelő” panel, melyen az éppen kiválasztott hálózat állandó tulajdonságai és a csak az adott számítási iterációban jellemző változó tulajdonságai jelenek meg. A programablak közepén zöld négyszögben a „Központi állapotpanel” foglal helyet, ahol a betöltött hálózatok állapotai jelennek meg. Ezek közül az aktuálisan kiválasztott hálózat bal oldalon, míg az összehasonlított hálózat jobb oldalon látható. 2.5.2 Központi állapotpanel 2.5.2.1 Állapotmegjelenítő panel A „Központi állapotpanel” két részre osztható: bal oldalán található az „Állapotmegjelenítő” panel, melyen füleken tárolódnak a megnyitott hálózatok, és a legfelső fülön elhelyezkedő hálózatot tekinti a program „kiválasztott hálózatnak”, melyre a felhasználói felület interakciós gombjai vonatkoznak. Ezen hálózat csúcsainak az állapotait lehet figyelemmel követni a különböző betöltött iterációk változása során ezen a panelen. Egy adott csúcshoz tartozó szavak a csúcs azonosítója alatt külön sorokban találhatóak. 2.5.2.2 Összehasonlító panel A „Központi állapotpanel” jobb oldalán az „Összehasonlító” panel foglal helyet. A betöltött hálózatok közül lehetőség van erre a panelre átmásolni egy hálózat állapotát. Ekkor a rendszer következő funkciói egyszerre vonatkoznak mind a kiválasztott mind az összehasonlított hálózatra:

14



A „Compute” gomb által indított számítási iterációk elvégződnek mindkét hálózatra.



A „Next”, „Previous” valamint az „Jump to” gombok lenyomásával a kiválasztott és az összehasonlított hálózat is betölti a megfelelő iterációs lépés szavait, amennyiben ki van számítva az adott iteráció mindkét oldalon. A hálózatok léptetése csak ebben az esetben lehetséges, egyébként a kérdéses léptető gomb inaktív, megadott iterációra ugráskor pedig felugró ablakon tájékoztat a szoftver arról, hogy legalább az egyik panelnek számításra van szüksége az adott iterációs lépés betöltéséhez.



A szópopulációt szemléltető grafikon egyszerre jeleníti meg mindkét hálózat szavainak a növekedési ütemét mutató függvényeket.

2.5.2.3 Szavak színkódolása A megjelenített hálózat azon szavait, melyeket az adott iterációban a beállított protokoll és „trigger” szerint kommunikálandó szóként jelöl meg a program, a rendszer piros színnel jelöli, a többi szót pedig feketével. Ezen jelölés rendszer használatával érhető el, hogy a felhasználónak nem feltétlenül kell a „Megfigyelő” panel megfelelő lapjára kapcsolnia, ha kíváncsi az elküldött szavakra, és így egyszerre láthatja a hálózat tulajdonságait és a kiemelt szavakat – amennyiben a hálózat állapota elfér a felhasználó képernyőjén. A 3. ábrán látható az „Állapotmegjelenítő” panel egy betöltött iterációs lépésben.

15

3. ábra: Állapotmegjelenítő panel

A 3. ábrán lévő „Állapotmegjelenítő” panel részlet színkódolásán egy új jelölés figyelhető meg, a zöld karakterszín. Ha az összehasonlító panel nem üres, és a rajta lévő hálózat mérete megegyezik a kiválasztott hálózat méretével – vagyis mindkét hálózat ugyanannyi csúcsból épül fel –, akkor a színkódolás a következőképpen alakul: 

Fekete színnel jelöltek azok a szavak, melyek mindkét hálózat azonos indexű csúcsának állapotában megtalálhatóak.



Zöld színűek azok a szavak, melyek megtalálhatóak a kiválasztott hálózat adott indexű csúcsának a szóhalmazában, de az összehasonlított hálózat azonos indexű csúcsában nem.



Fordított esetben, amikor az adott szó csak az összehasonlított hálózat csúcsában létezik, a szó kék színnel fog megjelenni.



Ha egy szó kommunikációra van kijelölve az adott iterációban, akkor egyéb körülményektől függetlenül mindig piros színnel lesz feltüntetve.

Az 3. ábrán látható esetben tehát: 

Az a1 és a1^5 szavak szerepelnek a – mutatott ábrán nem látható – „Összehasonlító” panelen elhelyezkedő hálózat első csúcsának szavai között is, ezért fekete színűek. 16



Az a1 a2^9 b3^9, az a^7 és az a^13 szavak a kiválasztott hálózat első csúcsában szerepelek, az összehasonlított hálózat első csúcsában viszont nem, ezért zöld színűek.



Az a1 a2^9 b3^9 szó a kiválasztott hálózat második csúcsában az adott iterációban kommunikációra lett kijelölve, ezért piros színű.

2.5.2.4 Állapotmegjelenítő és Összehasonlító panel fejléce Az 3. ábrán megfigyelhető „Állapotmegjelenítő” panel lapfülei mutatják a betöltött hálózatok azonosítóit, és ezekre a fülekre való kattintással van lehetőség másik megnyitott hálózat kiválasztására. A példán a network3_1_patsta nevű hálózat van kiválasztva, a network3_patu49 pedig egy további memóriába betöltött hálózat. Az „Állapotmegjelenítő” panel fejlécében látható a megnyitott hálózatok száma, míg az „Összehasonlító” panel fejlécében az összehasonlításra kiválasztott hálózat azonosítója látszik. 2.5.3 Megfigyelő panel 2.5.3.1 Megfigyelő panel felépítése A program ablak jobb oldalán elhelyezkedő „Megfigyelő” panel hivatott a vizsgált hálózat valamint az aktuális iteráció tulajdonságainak és jellemzőinek monitorozására. A megjelenő információk három lapra vannak elosztva, melyek között fülek segítségével lehet váltani.

17

4. ábra: Megfigyelő panel

Az 4. ábrán a „Megfigyelő” panel látható megnyitott hálózat esetén. Fejlécében a vizsgált hálózat azonosítója olvasható, alatta pedig a füleken nyílik lehetőség másik lapra váltani, ha az iteráció vagy a hálózat más tulajdonságaira vagyunk kíváncsiak. A „Megfigyelő” panel lapjai a következők: 

„Tulajdonság megfigyelő”: Ezen a lapon a kiválasztott hálózat alap tulajdonságai jelennek meg, azaz: o

hálózat azonosítója;

o

hálózat mérete;

o

ábécé mérete;

o

protokoll;

o

„trigger”;

o

morfizmus;

o

szópopuláció.

18



„Út megfigyelő”: A hálózat csúcsainak Watson-Crick útja látható ezen a lapon. A bitsorozat tíz bitből álló részszavakra van bontva, és így egymás mellé helyezett „dobozokban” kerül megjelenítésre. A „dobozok” alsó részében maga a bitsorozat részlet látható, a bal felső sarokban az első megjelenített bitnek a teljes bitsorozatban vett indexe, a jobb felső sarokban pedig az utolsó bitnek az indexe. Ezen kívül információt kapunk az adott csúcs kommunikációs viselkedéséről is.



„Iteráció megfigyelő”: Ezen a lapon a betöltött iterációs lépésre jellemző szó populációról és a kommunikált szavakról kapunk tájékoztatást, szintén csúcsokra lebontva. Az „Út megfigyelő” és az „Iteráció megfigyelő” felülete látható az 5. és a 6.

ábrán.

5. ábra: Út megfigyelő panel

6. ábra: Iteráció megfigyelő panel

2.5.4 Hálózat tulajdonság szerkesztő panel A „Hálózati tulajdonság szerkesztő” panel a program azon felülete, mely új hálózat létrehozására illetve megnyitott hálózat módosítására kínál lehetőséget. Ez a panel a program indításakor nem látható, és a „New” gombra vagy a „Modify” gombra kattintva jelenik meg a programablak bal oldalán. Az új hálózat létrehozásának és a már megnyitott hálózat módosításának a menete csak kismértékben tér el, mivel a módosítás művelet egy új hálózat létrehozását kezdeményezi, ahol a beviteli mezők alapértelmezetten ki vannak töltve a módosítandó hálózat tulajdonságaival. Ezeket a mezőket tudjuk elképzelésünk szerint átírni, így létrehozva egy olyan új hálózatot, mely csak az átírt tulajdonságokban tér el az eredeti hálózattól. 19

A hálózat módosítás tehát érintetlenül hagyja az eredeti hálózatunkat, így lehetőségünk nyílik egyazon struktúrán több egymástól különálló változtatást végezni, és megfigyelni az így létrejött hálózatok és az eredeti hálózat állapotainak az alakulása közötti eltéréseket. Az új hálózat létrehozásának a menete a következő: 

Kattintsunk az eszköztár „New” gombjára, hogy megjelenjen a „Hálózat tulajdonság szerkesztő” panel.



Adjuk meg a hálózat azonosítóját (rendszerbeli nevét), a hálózat méretét (csúcsok

számát),

és

a

legördülő

menükből

válasszunk

az

elképzeléseinknek megfelelő protokollt és „triggert” (a protokollról és a „triggerről” bővebben az 1.2 pontban olvashatunk). 

Amennyiben „egyéni triggert” választottunk, adjunk meg a felugró inputablak beviteli mezőjébe egy kettő és száz közötti egész számot, ami a hálózat „triggerének” arányát fogja jelenteni. Ezen beállítás szerint a „trigger” akkor fog bekapcsolni, ha az adott szóban a pirimidin betűk száma eléri az adott szót felépítő betűk triggernek megadott számnyi százalékát. Tehát ha „egyéni triggerként” megadjuk a 40-es számot, akkor a rendszer komplemens átírást fog végezni az adott szón, ha az abban található pirimidin betűk száma nagyobb, mint a szó hosszának a 40 százaléka. Ebben az esetben nem garantált, hogy az átírt szó „helyes” lesz, azonban ez a lehetőség a program használatát általánosabb feltételek mellett is lehetővé teszi.



A panel alján található „Done” gomb megnyomása után megjelenik a hálózat méretének és ábécé méretének megfelelő számú kezdőaxiómát és morfizmust beállító beviteli mező. A „Done” gomb a panel alján elhelyezkedő gomb egy „pipa” szimbólummal.



Minden csúcsnak választanunk kell, egy – a megadott „trigger” szerint helyes – axiómát, amely nem lehet az üres szó.



Minden csúcs morfizmusában minden betűhöz tartozó szabály ki kell töltenünk, a szabályok jobb oldala nem lehet az üres szó.



Mind az axióma mind a morfizmus beviteli mezőibe a megadott ábécének megfelelő betűket kell beírnunk, szóközökkel elválasztva. 20

Amennyiben helytelenül töltjük ki ezeket a mezőket, a program felugró ablakban tájékoztat a kitöltés helytelenségéről, és lehetőségünk nyílik kijavítani a rosszul megadott adatokat. 

Miután befejeztük az adatok beírását, kattintsunk ismét a „Done” gombra, aminek hatására eltűnik a „Hálózat tulajdonság szerkesztő” panel, és a létrehozott hálózat megjelenik az „Állapotmegjelenítő” panel betöltött hálózatai között.

Meglévő hálózat módosítása során hasonlóan kell eljárnunk ahhoz, mintha új hálózatot hoznánk létre, a különbség mindössze annyi, hogy ekkor a beviteli mezők már ki vannak töltve a módosítandó hálózat adataival, és nekünk csak ezeket az adatokat kell elképzelésünk szerint megváltoztatni. Módosításnál az új hálózat kap három alapértelmezett

értéket,

melyet

át

kell

állítanunk,

ha

nem

felel

meg

az

elképzeléseinknek. Ezek az alapértelmezett adatok a következők: 

Az új hálózat neve megegyezik a módosítandó hálózat nevével, amihez egy „_1” toldalék kerül. Ha például a módosítandó hálózat neve network3, akkor az új módosított hálózat neve alapértelmezésben network3_1 lesz. Erre azért van szükség, mert több azonos nevű hálózat nem lehet egyszerre megnyitva a programban.



Az alapértelmezett protokoll az (a) protokoll.



Az alapértelmezett „trigger” a „Standard trigger”.

Amennyiben a hálózat létrehozás, vagy módosítás műveletet mégsem szeretnénk befejezni, lehetőség annak megszakítására, a „Cancel” gomb megnyomásával, mely egy „X” szimbólummal ellátott gomb a panel jobb alsó sarkában. A gomb megnyomása után a „Hálózat tulajdonság szerkesztő” panel eltűnik, és az új hálózatnak megadott adatok elvesznek. A „Hálózat tulajdonság szerkesztő” panel új hálózat létrehozás esetén a 7. ábrán, módosítás esetén pedig a 8. ábrán látható.

21

7. ábra: új hálózat létrehozása

8. ábra: hálózat módosítása

2.6 Felhasználói felület eszköztárának és menüjének bemutatása A hálózatok léptetésének és számításának a kivételével az összes programba beépített művelet az eszköztárról vagy a menüről érhető el. Ezek a műveletek három logikai csoportra osztatók; a fájlműveletek, a hálózatkezelő műveletek és az egyéb funkciók. A logikai csoportok elemei a következők: 

Fájlműveletek: o

Új hálózat létrehozása 22

o 



Hálózat törlése

Hálózatkezelő műveletek: o

Meglévő hálózat megnyitása

o

Hálózat módosítása

o

Hálózat bezárása

Egyéb funkciók: o

Hálózatok összehasonlítása

o

Szópopuláció diagram megjelenítése

o

Számítási napló kikapcsolása / bekapcsolása

o

Program névjegyének megtekintése

9. ábra: menü és eszköztár

A 9. ábrán megfigyelhető, hogy a program menüje és az eszköztára mellett jobb oldalt egy rendszerinformációs sáv is helyet foglal. Itt tájékoztat a program arról, hogy a legutóbb végrehajtott művelet sikeresen, vagy sikertelenül fejeződött be, illetve számítási művelet befejeztével is itt látható a számítási iteráció futási ideje. Az ábrán látható esetben egy hálózat sikeres megnyitását tudatja velünk a szoftver. 2.6.1 Menüsáv A szoftver ablakának a bal fölső sarkában helyezkedik el a menüsáv, melynek két menüpontja a „File” menü és a „Options” menü. A „File” menü az alábbi almenüket tartalmazza: 

„New”: Erre a menüre való kattintáskor megjelenik a „Hálózat tulajdonság szerkesztő” panel, és megkezdődik a rendszerben egy új hálózat létrehozásának folyamata. Erről a 2.5.4 pontban olvashatunk bővebben.



„Delete”: A „Delete” menüpont választása esetén megjelenik egy megerősítést kérő ablak, melyen a „Yes” gombra kattintva bezáródik a kiválasztott hálózat, a hozzá tartozó hálózati struktúra és állapot struktúra fájlok pedig törlődnek a háttértárról. A „No” gombra kattintva nem történik változás a hálózaton. 23



„Open”: A háttértáron található

hálózat struktúra fájlok segítségével

lehetőségünk van korábban létrehozott hálózatokon folytatni a munkát. A hálózati struktúra fájlokat a network/structure könyvtárba menti a program, és ez a mappa nyílik meg akkor is, ha az „Open” menüpontot választva tallózunk a mentett hálózatok között. Ilyen esetben betöltődik a kiválasztott hálózat állapot struktúrája is, így nem kell újra számítást végezni a hálózaton, mert a korábban kiszámított iterációk eredményét ugyanúgy kezeli a program, mintha a betöltés után számítottuk volna ki. Ha a hálózati struktúra fájlt nem a structure könyvtárból töltjük be, a hálózat létrejön a rendszerben, de a hozzá tartozó állapot fájl (ha van ilyen) nem kerül betöltésre. Ilyen esetben egy új hálózat struktúra és állapot fájl jön létre a megfelelő mappákban, és a betöltés után végzett számítási lépések eredményei is elmentésre kerülnek. Ugyanazzal az azonosítóval nem tölthető be két hálózat – vagy ugyanaz a hálózat kétszer. 

„Modify”: A „Modify” menüpontra való kattintással lehet megkezdeni a kiválasztott hálózat tulajdonságainak módosítását. Erről a 2.5.4 pontban olvashatunk bővebben.



„Close”: A „Close” menüpontot választva tudjuk a kiválasztott hálózatot szabályosan bezárni és törölni a memóriából. Bezárás után a hálózathoz tartozó struktúra fájlok megmaradnak a háttértáron, így bármikor újra betölthetjük azt az „Open” menüpont segítségével.



„Exit”: Az „Exit” menüpontot választva a program futása leáll, a programablak pedig bezáródik.

Az „Options” menü az alábbi almenüket tartalmazza: 

„Compute Log On”: A számítási naplózást engedélyező menüpont. A számítási naplózás a program egy olyan funkciója, mely részletes betekintést enged a számítási folyamatok lépéseibe. Ha ez a menüpont be van kapcsolva, akkor a számítási

iterációk

minden

lépése

szövegesen

elmentésre

kerül

a

compute.log fájlba a program könyvár log mappájában. Részlet a számítási naplóból a 10. ábrán látható.

24

10. ábra: számítási napló részlet



„Compute Log Off”: A számítási naplózást letiltó menüpont. Ha az aktuális kutatási munkánkhoz nem szükséges figyelemmel követnünk a számítási lépések lezajlásának pontos részleteit, és csak a számítás eredményére vagyunk kíváncsiak, akkor célszerű kikapcsolni a számítási naplózást. Ilyenkor nem történik naplófájlba írás, számítás közben, és ez által számottevő – szópopulációtól függően akár százszoros – teljesítménynövekedésre lehet számítani.



„About”: Az „About” menüre való kattintáskor felugró ablakban megjelenik a program névjegye. A névjegyet az „OK” gombbal tudjuk eltüntetni. A „Névjegy ablak” a 11. ábrán látható.

11. ábra: Névjegy ablak

25

2.6.2 Eszköztár A program fejlécében található eszköztáron megtalálhatóak a menüből is elérhető hálózat és fájl műveletek indító műveletek, de azok kiegészülnek két további funkcióval. A menüben és az eszköztáron is megtalálható műveletek: 

Új hálózat létrehozása



Kiválasztott hálózat módosítása



Hálózat megnyitása



Hálózat módosítása



Hálózat bezárása

Ezekről a funkciókról a 2.6.1 pontban található bővebb információ. Az eszköztár kiegészítő funkciói az „Összehasonlítás” művelet és a „Szópopuláció diagram”. 

„Compare”: Az eszköztár „Compare” gombjára kattintva a kiválasztott hálózat „állapotlapja” átmásolódik az „Összehasonlító” panelre, és lehetőség nyílik ezt és egy másik választott hálózatot összehasonlítani bármely iterációs lépésben, ameddig mind a két hálózat ki van számítva. Az összehasonlított és a kiválasztott hálózat együttes működéséről bővebben a 2.5.2.2 pontban olvashatunk.



„String Population Chart”: Az eszköztár "String Population Chart" gombjára kattintva nyílik lehetőség megtekinteni a kiválasztott – és összehasonlítás esetén az összehasonlított – hálózat szópopulációjának az alakulását kiszámított iterációk szerint. A megjelenített koordináta rendszer Y tengelyén a hálózat szavainak a száma, az X tengelyén pedig az iterációk vannak jelölve, a diagram alján pedig a vizsgált hálózat, vagy hálózatok nevei láthatók. A 12. ábrán a „Szópopuláció diagram” látható hálózatok összehasonlítása közben.

26

12. ábra: Szópopuláció diagram

2.7 Vezérlőpanel A programablak alján található a „Vezérlőpanel”, amely fő rendeltetése, hogy a kiválasztott és az összehasonlított hálózatok léptetését és számítását kezelő gomboknak helyet ad, valamint ezeknek a hálózatoknak a számított és betöltött iteráció számát megjeleníti. Részei az „Információs” panel és a „Számításvezérlő” panel.

13. ábra: Vezérlőpanel

2.7.1 Információs panel A 13. ábrán látható „Vezérlőpanel” két „Információs” panel felületet tartalmaz, ezek a lekerekített téglalapban található kiszámított iteráció számról és jelenleg betöltött iteráció számáról tájékoztató szövegekből és a fejlécben a hozzájuk tartozó hálózat azonosítójából épülnek fel. A bal oldali „Információs” panel az „Állapotmegjelenítő”

27

panel alatt helyezkedik el, a jobb oldali pedig az „Összehasonlító” panel alatt. Mindkét „Információs” panel a fölötte elhelyezkedő hálózat adatait hivatott mutatni. 2.7.2 Számításvezérlő panel A „Vezérlőpanel” közepén található „Számításvezérlő” panel a kiválasztott és az összehasonlított hálózat állapotán elvégzett változtatásokat kínáló gomboknak ad helyet. Valójában gombok és két beviteli mező csoportjából áll ez a panel. A „Számításvezérlő” panel felépítése balról jobbra haladva a következő: 

„Previous” gomb: Ennek a gombnak a lenyomásával a kiválasztott és az összehasonlított hálózaton tudjuk elvégezni a „Léptetés” műveletet eggyel negatív irányba.



„Compute” gomb: A kiválasztott és az összehasonlított hálózaton „Számítás” műveletet tudunk végezni ennek a gombnak a segítségével.



„Compute” beviteli mező: A mezőbe írt szám határozza meg, hogy hány iterációt számítson ki a rendszer, ha a „Compute” gombra kattintunk.



„Next” gomb: A „Next” gomb lenyomásával a kiválasztott és az összehasonlított hálózatra elvégződik a „Léptetés” művelet pozitív irányba.



„Jump to” gomb: Amennyiben egy megadott iterációra szeretnénk léptetni hálózatainkat, az „Jump to” gombot válasszuk, ez ugyanis egy választott számú iterációra végzi el a „Léptetés” műveletet. Különösen hasznos ez a gomb, ha nem a számítás legelejétől kívánjuk megfigyelni a hálózatok viselkedését, hanem egy megadott pozíciótól kezdve, illetve akkor, ha egy nagyméretű hálózattal dolgozunk, melynél a „Léptetés” művelet elvégzése több másodpercet vesz igénybe. Ekkor ha csak minden tízedik lépés fontos a kutatásunkhoz, rengeteg időt spórolhatunk ezen funkció igénybevételével.



„Jump to” beviteli mező: A mezőbe írt számmal megegyező számú iterációt tölthetjük be az „Jump to” gomb lenyomásával, amennyiben mind a kiválasztott, mind az összehasonlított hálózat ki van számítva eddig a lépésig. Ellenkező esetben felugró ablakban tájékoztat a program a számítás szükségességéről. 28

Abban az esetben, ha a gombokhoz kötött művelet elvégzése adott körülmények között nem lehetséges – például ha vissza akarunk lépni a kezdeti állapotból – akkor a gomb inaktív, és a megnyomása nem lehetséges. 2.7.3 Léptetés művelet A szoftver legfontosabb funkciója, hogy megadott Watson-Crick D0Lrendszerek hálózatainak az állapotait emberi szem számára jól átlátható módon megjeleníti és a „Megfigyelő” panel segítségével ezek tulajdonságait is szemlélteti. A hálózataink állapota a kiszámított iterációk során azonban változik, és ha figyelemmel szeretnénk kísérni ezt a változást – és nem csak egy végeredményre, például a hálózatok szópopulációjára vagyunk kíváncsiak – akkor váltanunk kell a különböző iterációk között, be kell töltenünk a rendszerbe azokat. Az iterációk közötti váltás, másik iteráció betöltésének a feladatát ellátó művelet neve „Léptetés”. Ennek a műveletnek a hívásakor a kiválasztott, és – ha van – az összehasonlított hálózat megjelenített állapota lecserélődik egy új meghatározott iterációban jellemző állapotra, és a program összes ezt elemző komponense – mint például a szószínezés, vagy a „Megfigyelő” panel – frissül ilyenkor, vagyis az új iterációra jellemző információkat jeleníti meg. 2.7.4 Számítás művelet Miután sikeresen létrehoztunk egy új hálózatot az a kezdeti állapotban, vagyis a kezdeti iterációban lesz látható az „Állapotmegjelenítő” panelen, és az azt léptető gombok inaktívak lesznek. Ez azért van, mert hálózat létrehozás után a hálózatunk még a struktúráját jelentő szabályokon kívül más információt nem hordoz, nincsen hozzá tartozó több iteráció, amit vizsgálhatnánk, és a „Szópopuláció diagram” is üres ekkor. A további iterációk betöltéséhez ki kell számítanunk ezeket az iterációkat, ehhez pedig a „Számítás” művelet elvégzésével lehetséges. A „Számítás” műveletet a „Számításvezérlő” panelen található „Compute” gomb lenyomásával tudunk indítani, amennyiben legalább egy hálózat meg van nyitva a rendszerben, ellenkező esetben ugyanis a gomb inaktív. A „Compute” gomb lenyomása után megjelenik a 14. ábrán látható „Számítási ablak”. 29

14. ábra: Számítás ablak

A „Számítási ablak” hivatott ellátni a felhasználót minden számítással kapcsolatos információval. Ilyen információk például, hogy a számítási folyamat a kiszámítandó iterációk mekkora hányadán fejeződött be – ezt a „Számítási ablak” felső részén látható állapotjelző csík mutatja – illetve, hogy a számítás sikeres befejeztével a számított hálózat, vagy hálózatok hány lépésig lesznek kiszámítva. A 14. ábrán látható példán két hálózatra is elvégződik a „Számítás” művelet: a network3_patsta és a network3_patu49 hálózat kiszámított iterációinak a száma is növekszik. Ez azért van, mert – a „Léptetés” művelethez hasonlóan – a „Számítás” művelet is elvégződik a kiválasztott hálózaton kívül az összehasonlított hálózatra is, amennyiben az létezik. A „Számítási ablakon” található két gomb is, melyek a számítási folyamat megszakítására használhatóak. Az ablak jobb alsó sarkában található „Interrupt” gomb a számítási folyamat szabályos leállítására hivatott. Ennek a gombnak a megnyomásakor a számítási folyamat leáll az aktuálisan számítás alatt lévő iteráció elvégzése után. Mivel azonban nem ritka az olyan eset, amikor a hálózat, amivel dolgozunk exponenciális növekedésű szóhalmazzal rendelkezik, és az adott iterációs lépés kiszámítása akár hosszabb időt is igénybe vehet, ezért természetesen szükséges lehet egy olyan lehetőség, mellyel bármikor be lehet fejezni a számítási folyamatot. Ezt a lehetőséget kínálja a „Force Exit” gomb.

30

Ha úgy szeretnénk leállítani a számítási folyamatot, hogy nem várjuk meg az adott iteráció kiszámításának a befejeződését, akkor a „Force Exit” gomb megnyomásával a számítási folyamat azonnal megszakad, és a program futása leáll. A számítási folyamat megszakításának ezt a módját csak akkor válasszuk, ha valami miatt azonnal be kell fejeznünk a számítást, és nem tudjuk megvárni, mire az adott iteráció kiszámítódik, ugyanis a megszakítás ilyen módja sérüléseket okozhat az állapot struktúra fájlokon, és bizonyos esetekben használhatatlanná teheti az adott hálózatot.

31

3. Fejlesztési dokumentáció A fejlesztési dokumentáció négy részre van tagolva. Először megállapítjuk, hogy mit és milyen módon kell majd megvalósítani, majd kitűzzük a főbb használati eseteket, amiket a programnak tartalmaznia kell. Ezek után a programot alkotó osztályok kerülnek bemutatásra, végül pedig a tesztelés következik. 3.1 Követelmények és megvalósítás 3.1.1 Követelmények A fejlesztés során egy fajta prioritási sorrendet kell felállítani a műveletigény, a memóriaigény, a könnyű kezelhetőség, a jó megjelenés és a könnyen karbantartható kód fölött. Mivel a felsorolt kritériumok közül több is van, amely csak egymás rovására bővíthető, ezért a tervezés során kompromisszumokat kell kötni. A szakdolgozat fő célja egy olyan kutató program létrehozása volt, mely segítségével a bevezetésben ismertetett Watson-Crick D0L rendszerek hálózatainak a működése egy egyszerű, áttekinthető és letisztult felhasználói felületen keresztül tanulmányozható. A logikailag egymáshoz tartozó funkciók könnyen elkülöníthetők a többitől, és a felület elrendezése jól áttekinthető. A programban modellezett hálózatok egyik legfontosabb jellemzője a hozzájuk tartozó állapot mely iterációnként történő változása alapvető fontossággal bír szinte bármely egyéb tulajdonságuk vizsgálatakor. Az állapotok szóhalmazait azonban ki kell számítani, a számítás eredményét pedig el kell tárolni, hogy a program működése során használni tudjuk azt. Mivel a számítási folyamat erőforrás és időigényes, ezért, hogy ne kelljen minden indítás után újra kiszámítani egy korábbi alkalommal már elvégzett számítást, a számítási folyamat eredménye azonnal elmentődik a háttértárra, ahonnan a későbbiekben bármikor beolvasva használni tudjuk az egyszer már előállított információkat. Mivel ezek a fontos adatok a felhasználó által használt tárolón helyezkednek el, ezért a tervezés elején választani kellett a memóriaigény és a töltési idő között, ugyanis ha minden lépésben a tárolóról olvassuk fel az adatokat, akkor a memóriában elegendő hálózatonként egyetlen iteráció állapotát tárolni, azonban a sok I/O művelet miatt 32

megnövekszik a töltési idő. Fordított esetben, ha egyszerre olvassuk fel a hálózat összes iterációjának az adatait, akkor sok nagyméretű hálózat esetén magas lehet a memóriaigény, viszont cserébe gyorsabb lesz a program működése, hiszen a memória műveletek sokkal gyorsabban hajtódnak végre, mint bármilyen I/O művelet. A program a második stratégia szellemében lett kivitelezve, mely a gyorsabb futással jobb felhasználói élményt és hatékonyabb munkát biztosít a felhasználónak, de feltételez egy kicsivel magasabb memória kapacitást, mint az első stratégia. Döntést kellett hozni a kód terjedelmével és a kód átláthatóságával – vagy bővíthetőségével – kapcsolatban is. Itt a bővíthetőségre és az átláthatóságra lett helyezve a hangsúly, amely hatására a programkód terjedelmesebb, az osztályok száma pedig nagyobb, mint a feltétlenül szükséges, de ugyanakkor egy későbbi módosítás, vagy bővítés sokkal gyorsabban és egyszerűbben kivitelezhető, mint fordított esetben. Az algoritmus műveletigénye a prioritási listában az utolsó, ez a lehetőségekhez képest optimalizálásra került. 3.1.2 Megvalósítás folyamata 1.

A megvalósítás első lépése a program koncepciójának a kidolgozása: a szoftver adott Watson-Crick D0L rendszerek hálózatainak az állapotait, valamint tulajdonságait jeleníti meg rendszerezve és különböző jelölésekkel (például színezéssel) kiegészítve, hogy megkönnyítse a felhasználó kutató munkáját.

2.

A program tervezését és felépítését tekintve strukturálisan két jól elkülönülő részre van osztva: az egyik a logikai rész, mely tulajdonképpen a rendszer „motorja”, itt történik mindenfajta számítási, adattárolási és rendszerezési művelet, míg a másik a megjelenítési rész, ami a logikai rész eredményeit felhasználva megjeleníti az adatokat a felhasználó igényei szerint. Ezen tervezési megfontolás miatt a felhasználó közvetlenül nem érintkezik a logikai résszel, hanem a grafikai felületen keresztül kéréseket küld neki, majd ezek eredményét felhasználva folytatja a program használatát.

3.

Mivel a rendszerlogika a grafikus felülettől szinte teljesen el van választva, ezért kézenfekvő először a program ezen részének az 33

implementálása, és csak utána a grafikus felület megvalósítása, amely tulajdonképpen csak a kiszámított adatokat jeleníti meg, és a felhasználó parancsait továbbítja a rendszerlogikának. 4.

A rendszerlogika három részre osztható: Először kivitelezésre kerül magának a Watson-Crick D0L rendszernek és hálózatainak a modellezése, utána az ennek működését vezérlő és formázott megjelenítését kezelő programrészek megvalósítása, végül a számítási eredmények fájlba mentését megvalósító osztály implementálása következik.

5.

Bár a fejlesztés elején még tervben volt a csak konzolos működés opciójának megvalósítása, a későbbi fejlesztések során ez mégsem került kivitelezésre, mert ennek egyetlen előnye a grafikus felülettel szemben a gyorsabb működés lett volna, azonban a felhasználói felület – a számításhoz

képest

–

olyan

elhanyagolható

erőforrásigénnyel

rendelkezik, hogy az általa nyújtott színezési és egyéb megjelenítési lehetőségek hiányát egyszerűen nem kompenzálja a minimálisan gyorsabb futás. 6.

A rendszerlogika implementálása után kezdetét veszi a felhasználó felület kivitelezése, mely a program főbb paneleinek az elrendezésével, és a programablak kialakításával kezdődik.

7.

Miután a program ablak váza elkészült, elsőként a „Központi állapotmegjelenítő” panel implementálása kezdődik meg.

8.

Ezután a menü és az eszköztár kerül a helyére, melyekhez a műveletek bekötése folyamatosan történik, ahogy a műveletek implementációja befejeződik.

9.

Miután ez elkészült, a programablak alján elhelyezkedő „Vezérlőpanel” és a „Számításvezérlő” panel elkészítése kerül sorra.

10.

A fejlesztésnek ezen a pontján szintén módosítás történt projekt tervein, ugyanis a program eredetileg egy szálon futó alkalmazásnak indult. Mivel azonban az állapotjelző csík a Java Swing függvénykönyvtárában (JProgressBar) úgy lett implementálva, hogy szükséges a működéséhez egy párhuzamosan futó programszál, ezért a „Compute” művelet futtatása külön programszálon lett kivitelezve. Ez több okból is szükséges: egyrészt a felhasználónak fontos információ lehet, hogy a 34

számítási folyamat mekkora része végződött már el, másrészt így megvan a lehetőség megszakítani egy számítási iterációt, amennyiben erre

felmerül

az

igény.

Mindezek

megvalósítása

a

Swing

függvénykönyvtár SwingWorker osztályának az alkalmazásával történt, melyről a későbbiekben részletesebben olvashatunk. 11.

Ha ez elkészült, megkezdődik a „Hálózat tulajdonság szerkesztő” panel implementálása, a hozzá tartozó műveletekkel együtt.

12.

Ezek után a „Megfigyelő” panel és az ahhoz tartozó fülek tartalma kerül kivitelezésre.

13.

Végül a „Szópopuláció diagram” implementációjával, és a teszteléssel fejeződik be a program fejlesztése.

3.1.3 Használt fejlesztő eszköz A fejlesztés a Java alapú NetBeans IDE 7.3 integrált fejlesztői környezet keretei között történt. Ez a program grafikus fejlesztőfelületet kínál különböző alkalmazások elkészítéséhez, és segítségével könnyebben és gyorsabban tudjuk fejleszteni saját programjainkat. A projekt elkészítése során a legfontosabb kódolást segítő funkciói a beépített Java dokumentáció, a kiválóan működő és rengeteg időt megtakarító kódkiegészítés valamint a projekt menedzsment funkciók. 3.1.4 Használt külső függvénykönyvtár A program fejlesztése során egy külső függvénykönyvtár felhasználására is sor került: ez a JFreeChart. Az 1.3.2 pontban bemutatott keretrendszer az egyik legszélesebb körben használt Java alapú diagramkészítő eszköz, mely számos lehetősei közül csak egy lett felhasználva a programban, ez pedig a vonaldiagram, mely alkalmas választás a hálózatok szópopulációjának szemléltetésére az iterációk alapján. 3.2 Főbb használati esetek A következőkben a főbb használati esetek kerülnek bemutatásra.

35

A felhasználónak tudnia kell: 

új hálózatot létrehozni, vagy meglévő hálózatot megnyitni;



hálózat struktúráját módosítani;



hálózatot bezárni, vagyis törölni azt a memóriából;



hálózatot törölni a memóriából és a háttértárról;



hálózatot számítani;



hálózatot léptetni;



másik hálózatot kiválasztani;



kiválasztott hálózatot összehasonlítani másik hálózattal;



számítási naplózást kikapcsolni vagy bekapcsolni;



„Megfigyelő panelen” másik fülre kapcsolni;



„Szópopuláció diagramot” megnézni;



program névjegyét megtekinteni;



esetleges hibákról értesülni (például rosszul formázott bemenet).

15. ábra: használati esetek

36

3.3 Hálózat tulajdonság fájlok Amint arról már többször említés esett, a programban használt NWD0L rendszer modelleknek az állandó és a változó szerkezeteit is fájlba menti a rendszer, hogy a program egy későbbi használata során a munkánkat egy olyan hálózaton folytathassuk, melyet egy korábbi időpontban hoztunk létre – vagy akár egy másik kutató hozott létre. Egy hálózat egyértelmű azonosításához, és a programbeli modelljének a megalkotásához két különböző fájlra van szükség: az egyik ilyen fájl a hálózat struktúra fájl, míg a másik a hálózat állapot fájl. Előbbi a hálózat állandó tulajdonságait határozza meg (például a hálózat mérete, az ábécé mérete, a morfizmus) utóbbi pedig a hálózat állapotainak a számítási iterációnként vett felépítését. Mindkét alapvető információkat hordozó fájl formátuma XML, ugyanis ez a fájlformátum megkönnyíti a különböző architektúrák közötti adat mozgatást – figyelembe véve a program esetleges kiterjesztéseit, kibővítéseit – valamint az emberi szem számára is könnyebben átlátható, mint egy program specifikus adatfájl. Ezek a fájlok a program könyvtárában lévő network mappán belül található structure illetve state mappákban helyezkednek el. 3.3.1 Hálózat struktúra fájl Amikor egy új hálózat kerül létrehozásra, annak minden tulajdonsága elmentésre kerül egy úgynevezett hálózat struktúra fájlba. Ez a fájl nem módosul a létrehozása után, amikor hálózat módosítás történik, akkor egy új hálózat létrehozása kezdődik, melynél a hálózat tulajdonságainak a nagy része a módosítandó hálózat tulajdonságai szerint van alapértelmezettként beállítva. Erről a 2.5.4 pontban olvashatunk bővebben. Minden esetben, amikor a „Hálózat megnyitása” opciót választja a felhasználó, akkor ez alapján a struktúra fájl alapján történik a hálózat létrehozása, kiegészítve a hálózat állapot fájlal. Ha nem áll rendelkezésre a hálózathoz állapot fájl (mert nem a program natív mappájából nyitunk meg egy hálózatot), a rendszer akkor is képes létrehozni a hálózatot a megadott kezdeti axiómával, így egyedül a hálózat struktúra fájl megléte elégséges feltétel a hálózat létrehozásához.

37

A hálózat struktúra fájlok nevei a megegyeznek a hozzájuk tartozó hálózat azonosítójával, melyet a „.xml” utótag követ. A hálózat struktúra fájl formátuma XML, felépítése pedig a következő: 

A fájl első sora mindig az XML tulajdonságokat definiáló sor.



A gyökérelem a „network” tag, ebbe van ágyazva az összes többi eleme a fájlnak.



A gyökérelem első leszármazott eleme a „properties” elem, melybe a következő elemek vannak ágyazva:



o

„networksize”: megadja a hálózat méretét

o

„alphabetlength”: az ábécé mérete

o

„trigger”: a trigger beállításának kódja

o

„protocoll”: a protokoll beállításának kódja.

A „properties” elem után következik annyi darab „node” elem, amennyi a hálózat mérete, de legalább egy, mert üres hálózatot nem enged létrehozni a rendszer. o

A „node” elemhez tartozik egy tulajdonság is, méghozzá az „id”, ami a csúcs azonosítóját jelenti.

o

Az első „node” csúcsba ágyazott elem a „rules”, mely a csúcs morfizmusáról hordoz információkat. 

A „rules” az ábécé méretének a kétszeresével megegyező számú leszármazott elemet tartalmaz, melyeknek egyik fele „left”, másik fele pedig „right” elem. Ezek a leszármazott elemek rendre a morfizmus szabályának a baloldalát és a jobb oldalát határozzák meg.

o

A „rules” elemet az „axiom” elem követi a „rules” tag-be ágyazva. Itt foglal helyet az adott csúcshoz tartozó kezdőaxióma.

3.3.2 Hálózat állapot fájl A hálózatok számítása során nyert információk nemcsak a memóriában tárolódnak, hanem elmentésre kerülnek a háttértárra is, egy hálózat állapot fájlba. A hálózat struktúra fájlhoz hasonlóan minden hálózathoz egy ilyen fájl tartozik, amely ha

38

nem létezik a hálózat megnyitásának a pillanatában, akkor a rendszer automatikusan létrehozza a kezdeti állapottal. A hálózat állapot fájlok nevei a hozzájuk tartozó hálózat azonosítójával kezdődnek, majd a „_state.xml” utótaggal folytatódnak. Ennek az XML formátumú fájlnak a felépítése a következő: 

Az első sor mindig az XML tulajdonságokat definiáló sor.



A gyökérelem a „network” tag, ebbe van ágyazva az összes többi eleme a fájlnak.



A gyökérelem leszármazott elemei a „state” elemek, melyekből minden kiszámított iterációhoz egy tartozik, beleértve a kezdeti állapotot is. o

Minden „state” elemhez tartozik két tulajdonság: az első az „id”, mely az állapot sorszámát jelöli, másik pedig a „roadnum”, mely azt jelöli, hogy az adott iterációban hány kommunikáció történt összesen. Ha ez nulla, akkor a hálózatnak ehhez az iterációhoz tartozó Watson-Crick út bitje nulla, egyébként egy.



Minden „state” elembe beágyazva található még a hálózat méretével megegyező számú „node” elem, mely az adott iterációban a különböző csúcsok szóhalmazait írja le. o

A „node” elemekhez is két tulajdonság tartozik: az első az „id”, vagyis a csúcs azonosítója, a másik pedig a „roadnum”, ami a csúcs adott iterációjában történt kommunikációinak a számát jelzi.

o

Minden „node” elembe ágyazva megtalálható egy vagy több „axiom” elem, melyek az adott csúcs állapotának az elemeit jelölik, illetve amennyiben történt az iterációban kommunikáció a csúcs részéről, akkor „communicated” tag-ek közt is látható a küldött szó is.

Fontos megjegyzés, hogy mind a hálózat struktúra fájlokban, mind a hálózat állapot fájlokban a szavak „nem összevont megjelenítés” szerint szerepelnek. Erről a megjelenítési módról bővebben a 2.4.2 pontban olvashatunk.

39

3.4 Osztályok leírása 3.4.1 Bevezetés Az program tervezése során az egyik legfontosabb alapelv volt, hogy a grafikus megjelenítés, működés szintjén minél jobban elkülönüljön a rendszerlogikától, és a grafikus felület csak a már logikai programrész által kiszámított adatokat jelenítse meg, valamint lehetőséget biztosítson a felhasználó számára, hogy vezérelje a program rendszerlogikáját. Ez által, hogy a rendszerlogika lényegében független a grafikus interfésztől a szoftver egy magasabb fokú bővíthetőséget, a kód pedig jobb átláthatóságot nyer. Ez a fajta szétválasztás megfigyelhető a programkód struktúrájában is, ugyanis a kód két fő csomagra lett bontva: a logic csomagban a logikai osztályok találhatóak, a gui csomagban pedig a grafikus interfész osztályai. Megjegyzendő, hogy a szoftver minden osztályának a neve „NW” előtaggal kezdődik, röviden jelezve, hogy a „Networks of Watson-Crick D0L Systems” projekt részét képezik. Így ha egy fejlesztő bővíteni vagy karbantartani szeretné a program egy részét, vagy egészét, könnyen felismerheti, hogy mely osztályok közvetlen részei a programnak, és melyek külső függvénykönyvtárból importált osztályok. További megjegyzés, hogy a szoftver osztályainak és függvényeinek a nevében az „axiom” szó a „string” szinonimájaként van használva, a program működése során a legtöbb feldolgozandó „szót” – vagyis a hálózatok állapotainak az elemeit – „axiomnak” nevezzük a programon belül. 3.4.2 Logikai osztályok 3.4.2.1 Logikai osztályok áttekintése A logikai osztályok a logic nevű csomagban található osztályok, melyek a rendszer minden adattároló, számítási, és rendszerezési feladatát ellátják, valamint itt található az I/O műveletek megvalósításáért felelős osztály is. A 2. táblázat ad gyors áttekintést az ebben a csomagban található osztályokról.

40

Név

Feladatok

NWSytemLogic

a logikai programrész minden szegmensének az irányítása és összehangolása

NWFileManager

I/O műveletek megvalósítása

NWDisplayManager

hálózatok adatainak kimenet szerinti rendszerezése és formázása

NWAxiomMaskManager

szavak összevonása és színezése

NWNetworkFactory

hálózatok megfelelően felügyelt létrehozása

NWNetworkStructureFactory

hálózat struktúrák megfelelően felügyelt létrehozása

NWAlphabet

hálózat ábécéjének a programbeli megfelelője

NWMorphism

hálózat morfizmusának a programbeli megfelelője

NWNetwork

WD0LS hálózatának a programbeli megfelelője

NWNode

hálózat csúcsának programbeli megfelelője

NWTrigger

hálózat „trigger” feladatainak a megvalósítása

NWNetworkAxiomStructure

hálózat állapotának a tárolása

NWNetworkStructure

hálózat szerkezetének a tárolása

NWStateStructure

hálózatok összes állapotának a tárolása 2. táblázat: logikai osztályok

3.4.2.2 Az „NWSystemLogic” osztály Amint az osztály nevéből sejthető, az „NWSystemLogic” a program logikai főosztálya. Tervezése és megvalósítása a „Közvetítő” viselkedési tervezési minta alapján történt, mely rugalmasságot és bővíthetőséget garantál egy olyan környezetben, ahol

több

egymástól

különálló,

de egymással kommunikáló rendszert kell

összehangolni, és vezérelni. Ebben az osztályban vannak eltárolva és nyilvántartva a memóriába betöltött hálózatok „NWNetwork” objektumok formájában és a hozzájuk tartozó és adataikat formázó „NWDisplayManager” objektumok is. Ezen hálózatnak

a a

közvetítő

létrehozása,

osztályon amely

a

keresztül

történik

minden

createNetworkByStructure,

a

createNetworkByIdWithStateXml és a createNetworkByIdWithoutStateXml függvények valamelyikének a segítségével lehetséges, függően attól, hogy milyen módon kívánják a körülmények a hálózat létrehozását. Az első függvény hálózat 41

szerkezet objektumból, vagyis hálózat struktúra fájl nélkül hoz létre hálózatot, így teljesen új hálózat építésekor ez a metódus hívódik. Ha viszont megnyitunk egy már meglévő hálózatot, melyhez tartozik struktúra fájl, akkor függően a hálózathoz tartozó állapot fájltól (vagyis annak létezésétől) hívódik a második vagy a harmadik függvény, mely hiányzó állapot fájl esetén le is generálja azt. További alapvető fontosságú műveletek is megtalálhatóak az NWSystemLogic osztályban, mint például a computeNetwork függvény, mely a megadott hálózatot utasítja egy számítási lépés elvégzésére, vagy a requestStructureCreation, ami az NWNetworkStructureFactroy példányt állítja be új hálózat struktúra létrehozására.

16. ábra: NWSystemlogic osztálydiagramja

42

3.4.2.3 Az „NWFileManager” osztály Ez az osztály felelős a szoftver I/O műveleteinek az elvégzéséért. A szóba jövő fájlműveletek a következő csoportokra bonthatók: 

különböző naplózások;



hálózat struktúra fájlok olvasása és írása



hálózat állapot fájlok olvasása és írása

Két fajta naplózás is történik a rendszer működése közben: egyik a számítási naplózás, mely egy hálózat számítása közben részletekbe menően feljegyez minden számítási lépést. A számítási naplózás kikapcsolható. A másik fajta napló neve rendszernapló, mely a fontosabb műveletekről végez feljegyzést, mint például egy hálózat megnyitása, illetve a program futása során felmerülő hibákat is beleírja a rendszer ebbe a fájlba, például ha sérült szerkezetű egy hálózati struktúra fájl, és abból hálózat készítése nem lehetséges. A rendszernaplózásokért felelős függvények az esetek többségében konzolra is írnak, és lehetőség van az ilyen kiírások elejére időbélyeg megjelenítést kérni. A hálózat struktúra fájlok olvasása a loadNetworkStructureFromFile függvénnyel történik, a fájl létrehozása pedig a saveNetworkStructureToFile metódussal. Előbbi minden hálózat megnyitásakor tölti be a szükséges adatokat, míg utóbbi csak egy új hálózat létrehozások hívódik, létrehozván a hálózathoz tartozó hálózat struktúra fájlt. A hálózatokhoz tartozó állapot fájlok kezelése több metódust igényel: a loadWholeStateXml függvény a hálózat összes iterációjához tartozó állapotát betölti a hálózathoz tartozó NWDisplayManager példányba. Hálózat állapot fájl létrehozásához a createStateXml metódus, míg annak bővítéséhez (számítás eredményét elmenteni) az appendStateXml függvény használatos.

43

17. ábra: NWFileManager osztálydiagramja

3.4.2.4 Az „NWDisplayManager” osztály Az NWDisplayManager osztály feladata a memóriába betöltött hálózatok állapotainak a kimenet által felállított formai követelményeknek megfelelő formázása és rendszerezése. Minden hálózat létrejöttekor létrejön vele együtt egy hasonló azonosítóval rendelkező NWDisplayManager példány is, amely az NWNetwork példányhoz hasonlóan a rendszerlogikai osztály példányában kerül eltárolásra. Az első fontosabb adattag ebben az osztályban a communicationAxioms, amely a hálózat iterációihoz tartozó kommunikált szavakat tartalmazza csúcsokra lebontva. Szerkezete a következő: 

Legkívül egy lista, melyben minden elem egy adott iterációhoz tartozó adatokat tartalmaz.

44



Ebben a listában HashMap objektumok formájában reprezentálódnak a hálózat csúcsai, a map minden eleme egy csúcsnak felel meg.



A csúcsot szimbolizáló kulcs-érték pár kulcs tagja a csúcs azonosítója, értéke, pedig egy lista.



A kulcs-érték pár érték tagja egy olyan lista, melyben a csúcs adott iterációjában kommunikált szavai vannak eltárolva.

Ennek az adattagnak két függvényben is történhet a beállítása, az egyik az updateNodeAxioms függvény, másik a setCommunicationAxioms. Előbbi akkor hívódik, amikor számítást végzünk az adott hálózaton, másik pedig hálózat betöltése után, amikor az NWDisplayManager példány feltöltődik fájlból beolvasott adatokkal. Szintén a hálózat legfontosabb adatait rendszerező adattagok a nodeAxioms és a nodeRoad: az első a hálózat csúcsainak szóhalmazait tartalmazza iterációkra lebontva, a második pedig a hálózat Watson-Crick útját. Ezeken kívül nyilván kell még tartani az utolsó betöltött iteráció számát, mely a hálózat számításánál alapvető fontossággal bíró információ. Ezt a lastLoaded nevű változó tárolja.

45

18. ábra: NWDisplayManager osztálydiagramja

3.4.2.5 Az „NWAxiomMaskManager” osztály Ahogy az a 2.4.2 pontban bemutatásra került, a szoftver összevont és nem összevont formában is megjeleníti a szavakat, függően a megjelenítés céljától. A rendszerlogika legnagyobb részében nem összevont formában tárolódnak a szavak, ugyanis a program ebben az alakban képes műveleteket végezni rajtuk, összevont formára csak a kifejezetten kimenetre szánt szavak lesznek alakítva. Ezt az alakítást az NWAxiomMaskManager példány végzi. Egy másik szóformázás feladatát is ez az osztály végi el, ez pedig a szószínezés, amely a 2.5.2.3 pontban bemutatott módon történik.

46

19. ábra: NWAxiomMaskManager osztálydiagramja

3.4.2.6 A „Gyár” osztályok A hálózatoknak és azok szerkezetének a létrehozása egy olyan feladat, ami komoly felügyeletet igényel, és előnyös, ha ez nem a kódban bárhol történik, hanem egyetlen osztály végzi, lényegében teljesen automatizálva. Ezt a feladatot látja el az NWNetworkFactory és az NWNetworkStructureFactory. Az NWNetworkFactory osztály a „Gyár” létrehozási tervezési minta alapján lett tervezve. Egyetlen függvénye a create függvény, mely ellenőrzi a paraméterül kapott hálózat struktúrát, és ha az helyes, akkor létrehoz és visszaad egy NWNetwork példányt. Az NWNetworkStructureFactory kicsit másképpen működik, működése inkább az „Építő” tervezési mintára hasonlít, ám nem teljesen olyan. Itt a requestStructureCreation függvény hívása után – ami jelzi az osztálynak, hogy szeretnénk megkezdeni egy új struktúra létrehozását és beállítását – külön kell beállítanunk a különböző tulajdonságait a struktúrának, ami egy structure nevű adattag formájában található meg az osztályban. Miután befejeződött a struktúra beállítása,

a

getStructureInstance

függvény

visszaadja

az

NWNetworkStructure példányt, amit beállítottunk, és utána null-ra állítja azt.

47

20. ábra: NWNetworkFactory osztálydiagramja

21. ábra: NWNetworkStructureFactory osztálydiagramja

3.4.2.7 Az „NWNetwork” osztály Az „NWNetwork” osztály modellezi a Watson-Crick D0L rendszerek összefüggő gráfként összekötött hálózatát a programban. A hálózat csúcsai NWNode objektumok – melyekről bővebben a 3.4.2.9 pontban olvashatunk – amik a nodes listában vannak eltárolva. Ehhez az osztályhoz tartozik továbbá a hálózat protokollja és „triggere” is, ezeket rendre a protocol és trigger adattagok reprezentálják. Lényegében az NWNetwork osztály az NWSystemLogic osztályhoz hasonlóan közvetítő és összehangoló szerepet tölt be a rendszer működésében, csak míg az NWSystemLogic hálózatokat irányít, addig az NWNetwork csúcsokat. Ez a koordinátori feladat elsősorban a csúcsok számításában és azok kommunikációs igényeinek kielégítésében nyilvánul meg. A számítás a nextStep függvény hívásával indítható. Számítás során, ha egy csúcs egy szót kommunikációra kijelöl, akkor a hozzá tartozó NWNetwork objektum communicationRequest metódusának a hívásával jelzi ezt a közvetítő osztálynak. A

számítás

befejeztével

az

NWNetwork

osztályban

lefut

az

executeCommunication függvény, és a kommunikálandó szavak elküldődnek a küldő csúcs kivételével az összes csúcshoz.

48

22. ábra: NWNetwork osztálydiagramja

3.4.2.8 Az „NWTrigger” osztály Ez az osztály reprezentálja a NWD0LS trigger működését a programban. Mivel ennek az osztálynak az egyetlen feladata egy adott szó helyességének az eldöntése, ezért nincs szükség arra, hogy több példány létezzen belőle. Ennél fogva az NWTrigger az „Egyke” tervezési minta alapján lett megtervezve és implementálva, így ha egy szónak a helyességét kell ellenőrizni, akkor az osztály checkCorrection függvénye az osztályszintű instance példányon keresztül érhető el. Ennek a függvénynek paraméterül megadott érték alapján választódik ki, hogy milyen fajta „trigger” szerint legyen megállapítva az ellenőrizendő szó helyessége. Ezek az értékek lehetnek: 

0: Általános Trigger



1: Szigorú Trigger

49



2 – 99: Egyénileg Definiált Trigger

Jelen implementáció nagyban támogatja az esetleges későbbi kibővítést, új „trigger” bevezetését, ugyanis lényegében csak egy függvényt kell hozzáadni az osztályhoz, majd annak bevezetni egy kódot, és már elérhető is lesz az új „trigger”.

23. ábra: NWTrigger osztálydiagramja

3.4.2.9 Az „NWNode” osztály Az „NWNode” osztály valósítja meg az 1.2 pontban bevezetett WD0L rendszert. Legfontosabb adattagja az axiomSet halmaz, melyben az éppen betöltött iterációban jellemző szavakat tárolja a csúcs, és melyekkel számítás esetén dolgozik. Számítás indítása akkor történik, amikor a megadott NWNetwork objektum nextStep metódusa erre utasítja az NWNode példányt. Ekkor hívódik meg a compute metódus, és megkezdődik az axiomSet halmazban lévő elemek átírása, az átírt elemek ellenőrzése, valamint a kommunikációs kérelmek jelzése a hálózat felé. Amennyiben a számítási algoritmus szerint szükséges, komplemens átírást alkalmaz a csúcs az adott szóra a complement függvény meghívásával.

50

24. ábra: NWNode osztálydiagramja

3.4.2.10 Az adat struktúra osztályok A program futása során több fajta tisztán adatokat tartalmazó és azokon semmilyen műveletet sem végző osztály van alkalmazva. Ezek az osztályok az „NWNetworkAxiomStructure”, az „NWNetworkStructure” és az „NWStateStructure”. Elsődleges céljuk ezeknek az osztályoknak az, hogy egy adott rendszerrel kapcsolatos adatokat összefogják egy egységbe, és így egyszerűen és hatékonyan tudjuk továbbítani a program egyik szegmenséből a másikba. Az NWNetworkAxiomStructure osztály egy hálózat adott iterációjához tartozó állapotát, kommunikált szavainak a halmazát és a csúcsok Watson-Crick útjait foglalja magába. Ezeken kívül található még információ a hálózat kiszámított, és a struktúrában hordozott iteráció számáról, valamint az adott iterációban jellemző szópopuláció is. Az NWNetworkStrukture osztály szállít minden olyan információt, amely szükséges egy új hálózat létrehozásához. Amikor a felhasználó saját maga állít össze egy új hálózatot, akkor a bemeneti mezők adataiból egy NWNetworkStructure példány állítódik össze, illetve ilyen objektum készül akkor is, amikor az NWFileManager példány beolvassa és értelmezi a hálózathoz tartozó hálózat 51

struktúra

fájlt.

Ennek

az

osztálynak

a

példányosítása

kizárólag

az

NWNetworkStructureFactory osztályon keresztül lehetséges. Az utolsó adat struktúra osztály az NWStateStructure, mely egy hálózathoz tartozó összes iterációról hordoz adatokat: a csúcsok állapotait és kommunikált szóhalmazait, valamint a csúcsok Watson-Crick útját. Könnyű észrevenni, hogy az első és az utolsó adat struktúra nagyon hasonlít egymásra, ugyanis az egyik egy iteráció állapotának az adatait tartalmazza, míg másik az összes iteráció állapotainak az adatait. Természetesen megoldható lenne, kiváltani az NWNetworkAxiomStructure használatát az NWStateStructure osztállyal, ám a könnyebb kezelhetőség és a jobb átláthatóság miatt mégis mindkét osztály felhasználásra került a programban. 3.4.3 Grafikai osztályok 3.4.3.1 Grafikai osztályok áttekintése Grafikai osztályok a gui csomagban található osztályok, melyek célja a grafikus felhasználói felület felépítése, a logikai osztályok által előállított információk megjelenítése a felhasználó számára, valamint a kezelőfelület input komponensein keresztül – például egy gomb vagy szöveges mező – a felhasználó parancsainak a továbbítása a rendszerlogika felé. A 3. táblázat ad gyors áttekintést ezekről az osztályokról: Név

Feladatok

NWFrame

NWCentralPanel

programablak kerete, mely az alap komponenseket tartalmazza és összehangolja programablak főbb komponenseinek és a menü elemeknek az elkészítése állapotmegjelenítő panelek elhelyezése

NWAxiomDisplay

kiválasztott hálózat állapotának megjelenítése

NWCompareDisplay

összehasonlított hálózat állapotának megjelenítése

NWNetworkAxiomSheet

állapotmegjelenítő panelek komponense

NWAboutDialog

program névjegyének megjelenítése

NWObserverPanel

Megfigyelő panel kerete

NWPropertyObserver

kiválasztott hálózat tulajdonságainak megjelenítése

NWRoadObserver

kiválasztott hálózat csúcsaihoz tartozó Watson-Crick utak

NWGuiBuilder

52

NWPropertyEditor

megjelentése kiválasztott hálózatban betöltött iteráció tulajdonságainak a megjelenítése hálózat tulajdonság szerkesztő kerete

NWNetworkPropertyEditor

hálózat tulajdonság szerkesztő felület

NWNodePropertyEditor

csúcs tulajdonság szerkesztő felület

NWTriggerSetupDialog

„Egyéni Trigger” beállító ablak

NWStatusBar

Vezérlőpanel kerete

NWStatusBarButtonPanel

Számításvezérlő panel gombjainak elhelyezése

NWStatusBarInfoPanel

betöltött és számított iteráció számok mutatása

NWComputation

számítás grafikai felületének vezérlése

NWComputingDialog

számítási ablak megjelenítése

NWComputingSwingWorker

külön szálon történő számítás megvalósítása

NWStringPopulationChart

szópopuláció diagram megjelenítése

NWIterationObserver

3. táblázat: grafikai osztályok

3.4.3.2 Az „NWFrame” osztály Az „NWFrame” osztály két fontos szerepet tölt be a programban: egyrészt ez alkotja a program keretét, és a legkülső tárolót, amire a többi grafikai komponenst elhelyezzük, másrészt ez az osztály a grafikai osztályok közvetítő osztálya, vagyis hasonló szerepet tölt be a grafikai osztályok között, mint amit az NWSystemLogic a logikai osztályok között. Az NWFrame példány nem csak tartalmazza a többi grafikai komponenst, hanem az itt található actionPerformed metódus végzi a felületen található szinte összes input komponens (gombok, szöveges beviteli mezők, stb.) eseményparancsának a kezelését. A többi metódus az osztályban az actionPerformed függvény különböző ágainak az implementációja, melyek külön függvényként lettek kiszervezve, a kód jobb átláthatósága miatt. Az acionPerformed függvény ágait, és azok feladatait a 4. táblázat szemlélteti. Eseményparancs neve

Működés röviden

„New”

Új hálózat létrehozásához beállítja az NWPropertyEditor példányt, majd láthatóvá teszi azt.

„Delete”

Felugró ablakon kér megerősítést a törlésre, majd meghívja az

NWFileManager deleteNetworkFile metódusát.

53

Először egy JFileChooser segítségével kiválasztja a

„Open”

megnyitandó hálózat struktúráját, majd ha ez nem üres, akkor meghívja az NWFileManager megfelelő hálózat létrehozó függvényét. Módosításra beállítja az NWPropertyEditor példányt, és

„Modify”

láthatóvá teszi azt. Ha nincs megnyitott hálózat felugró ablakban tájékoztat a hibáról. Eltávolítja a kiválasztott hálózat állapotlapját, majd meghívja a

„Close”

rendszerlogika removeNetwork metódusát. Ha ez a hálózat volt összehasonlítva, akkor az NWCompareDisplay objektum cleanComparePanel függvényét is meghívja. A rendszerlogika megfelelő NWDisplayManager

„Previous”

példányától elkéri a hálózatokhoz tartozó

NWNetworkAxiomStructure adathordozókat, és ezekből a step függvény segítségével lépteti a hálózatokat visszafelé eggyel. „Compute”

Elkészít egy új NWComputing objektumot, és elindítja azt.

„Next”

Eggyel előre lépteti a kiválasztott és az összehasonlított hálózatokat. A megadott iterációra léptet a kiválasztott és az összehasonlított

„Jump to”

hálózatot, ha ki vannak azok számítva a megfelelő iterációig. A kiválasztott hálózat állapotlapját az összehasonlító panelre

„Compare”

másolja. Ha nincs beállítva az NWNodePropertyEditor példány,

„Done”

akkor beállítja és megjeleníti azt, egyébként ellenőrzi a bevitt adatokat, és ha azok helyesek, akkor létrehoz egy új

NWNetworkStructure példány. Törli az NWPropertyEditor objektumnak megadott

„Cancel new”

adatokat, és láthatatlanná teszi azt. „StringPopulationDialog”

Létrehoz egy új NWStringPopulationChart objektumot, és láthatóvá teszi azt.

„Exit”

System.exit(0) függvény hívásával leállítja a programot.

„About”

Megjelenít egy NWAboutDialog példányt. 4. táblázat: NWFrame actionPerformed függvényének ágai

54

Fontos kiemelni, hogy ez az osztály az, amely képes közvetlen kapcsolatot teremteni a logikai főosztállyal, és így vezérelni a program teljes működését.

25. ábra: NWFrame osztálydiagramja

3.4.3.3 Az „NWGuiBuilder” osztály Ez az osztály egyedül a kód átláthatóság és a karbantarthatóság miatt létezik, ugyanis ezek az okok azok, amik miatt ki lett emelve az NWFrame osztályból a különböző gui elemek létrehozása és azok beállítása. Mivel az esetleges többszöri 55

példányosítást mindenképpen szeretnénk elkerülni, ezért ez az osztály is az „Egyke” tervezési minta alapján készült, így a konstruktora le van tiltva. Az alapvető grafikai elemek felépítésén és beállításán kívül két említésre méltó funkciót érdemes kiemelni: első, hogy az NWPropertyEditor osztály frissítéséhez itt található a refreshPropertyEditor nevű függvény, mely alapbeállításba helyezi ezt az objektumot. A másik fontos függvény a setLookAndFeel, mely a program teljes megjelenésére nagy hatást gyakorol, ugyanis beállítja a „Nimbus look and feel” sémát. A „Nimbus” egy olyan platform független megjelenítési séma, vagy „look and feel”, mely a Java SE 6 Update 10 megjelenése óta érhető el, és alapértelmezetten beállított témája az OpenSolaris operációs rendszernek.

26. ábra: NWGuiBuilder osztálydiagramja

3.4.3.4 A „Központi állapotmegjelenítő” panelek A program ablak középső részén elhelyezkedő paneleket összefoglaló nevükön „Központ állapotmegjelenítő” paneleknek nevezzük. A legkülső kizárólag tároló szerepet

betöltő

panel

neve

NWCentralPanel,

mely

tartalmazza

az

NWAxiomDisplay és az NWComparePanel osztályok példányait, továbbá az NWStatusBar osztály példányát is, melyről később olvashatunk bővebben. 56

Az NWCentralPanel a szó szoros értelmében egy tároló, egyetlen célja, hogy elhelyezze a képernyőn a megnyitott hálózatokat tartalmazó NWAxiomDisplay panelt, mely a beállított rendező LayoutManager szerint „WEST” pozícióba kerül, és az összehasonlított hálózatot megjelenítő NWComparePanel panelt, mely „EAST” pozícióban helyezkedik el. Az NWFrame közvetítő osztály is az NWCentralPanel példányon keresztül érheti el ezeket az osztályokat. Az NWAxiomDisplay osztály jeleníti meg a betöltött hálózatok állapotait egy rajta elhelyezett JTabbedPane objektum lapfülein, és az éppen legfelül lévő fülön található hálózatra vonatkozik a programban szinte minden művelet, ez a „kiválasztott hálózat”. Az osztály axiomSheets nevű listájában tárolódnak a szintén az osztályon példányokból

NWNetworkAxiomStructure

belül

létrehozott

NWNetworkAxiomSheet objektumok, melyek a tényleges szóhalmaz információit mutatják. Kezdeti állapotban, vagy ha bezártunk minden megnyitott hálózatot, akkor az üres panelt egy kép díszíti, mely a program pic mappájában dna.png névvel található meg. Az NWComparePanel felületére másolódik a kiválasztott hálózat, ha az „Compare”

gombot

választjuk.

Kezdeti

állapotban,

vagy

ha

bezártuk

az

NWAxiomDisplay példányon az összehasonlított hálózat állapotlapját, akkor ezt a panelt is egy kép díszíti, mely a pic mappában található meg compare_big.png fájlnévvel. A panelt, amellyel az NWAxiomDisplay és az NWComparePanel is dolgozik, „NWNetworkAxiomSheet”-nek, vagy állapotlapnak nevezzük. Ezen a panelen jelennek meg ténylegesen a hozzájuk tartozó hálózat csúcsainak az állapotai, rendezve és megjelenítési

igényeknek

megfelelően

megformázva.

Ezt

a

feladatot

a

buildAxiomSheet és a refreshAxiomSheet függvények látják el. Az NWNetworkAxiomSheet

előre

összeállított

NWNetworkAxiomStructure

adathordozó objektumokkal dolgozik, melyben a szavak formázása az NWFrame osztály step metódusában történik. Az osztály csak egy bizonyos szóhosszig jeleníti meg a szavakat, melyek, ha összevont alakban 5000 karakternél hosszabbak (szóközöket is beleértve), akkor a szónak csak az első 4990 karaktere jelenik meg, és utána „…” jelölés tudatja a 57

felhasználóval, hogy szó vége le lett vágva. Erre azért van szükség, hogy a többi rövidebb szónak a megfigyelése kényelmesebben történhessen, és ekkora szóhossz felett megkérdőjelezhető, hogy egyáltalán lehetséges-e emberi szemmel figyelemmel követni egy „string” változásait.

27. ábra NWAxiomDisplay osztálydiagramja

28. ábra NWCompareDisplay osztálydiagramja

58

29. ábra NWCentralPanel osztálydiagramja

30. ábra NWNetworkAxiomSheet osztálydiagramja

3.4.3.5 Az „NWStatusBar” és a hozzá tartozó osztályok A felhasználói felület alján látható „NWStatusBar” panel két cél szolgál: egyrészt megjeleníti a kiválasztott és az összehasonlított hálózatok neveit, betöltött és maximálisan kiszámított iterációinak a számát, másrészt helyet ad a hálózatok vezérléséhez esszenciális „Számításvezérlő” panelnek. Az NWStatusbar példány az NWCentralPanel felületén „SOUTH” pozícióban helyezkedik el.

59

Ez

az

osztály

két

különböző

fajta

panelt

tartalmaz,

az

egyik

az

NWStatusBarInfoPanel, melyből két darab található rajta, egy „EAST” egy pedig „WEST” pozícióban elhelyezve, a másik pedig az NWStatusBarButtonPanel, mely középen található. Az NWStatusBarInfoPanel jeleníti meg a hozzá tartozó hálózat számított és betöltött iterációinak a számát. A baloldalon elhelyezkedő panel mindig a kiválasztott, a jobboldali pedig mindig az összehasonlított hálózat adatait mutatja. A panel frissítése a refreshInfoPanel függvénnyel történik. Az NWStatusBarButtonPanel tartalmazza a 2.7.2 pontban bemutatott „Számításvezérlő” panel gombjait és beviteli mezőit. A gombok actionCommand tulajdonsága kerül beállításra az osztályon belül, actionPerformed metódus nem kapcsolódik hozzájuk, ezt az NWFrame osztály kezeli. A JTextField mezők bemenetének ellenőrzését a checkInputCorrection függvény végzi.

31. ábra NWStatusBar osztálydiagramja

32. ábra NWStatusBarInfoPanel osztálydiagramja

60

33. ábra NWStatusBarButtonPanel osztálydiagramja

3.4.3.6 Az „NWObserverPanel” és részei Az „NWObserverPanel” osztály feladata megjeleníteni a kiválasztott hálózat minden állandó és adott iterációra leszűkített tulajdonságát. Ezt a feladatot három másik osztály:

az

NWPropertyObserver,

az

NWRoadObserver

és

az

meg

az

NWIterationObserver segítségével látja el. Ha

nincs

megnyitva

hálózat,

akkor

díszítő

kép

jelenik

NWObserverPanel felületén, mely a pic mappában observer.png néven található meg. Amennyiben meg van nyitva legalább egy hálózat (azaz a kiválasztott hálózat nem null), akkor az NWObserverPanel felületén három lapfülön megjelenik a három segédosztály példánya, melyek frissítése a refreshObserverPane metódussal

lehetséges,

mely mindegyik

osztály frissítését

végző

függvényt

meghívhatja, de hogy pontosan melyeket, azt paraméterezéssel lehet eldönteni. Az első lapon található az NWPropertyObserver, mely a hálózat állandó tulajdonságait jeleníti meg, mint például az ábécé mérete, a hálózat mérete vagy a morfizmus szabályai. A morfizmust megjelenítő függvény a buildNodePart, az össze többi tulajdonság megjelenítését a buildNetworkPart végzi. 61

A második lapon helyezkedik el az NWRoadObserver, ami a hálózat csúcsainak a kommunikációs viselkedéséről ad információkat, és a csúcsok WatsonCrick útjáról. Ezeket az információkat az NWObserverPanel példányban található NWNetworkAxiomStructure objektum computedRoad adattagjából nyeri az osztály. Az utolsó lapon található az NWIterationObserver, ami az aktuálisan betöltött

iterációban

történt

kommunikációkról

–

pontosabban

a

küldött

szavakról – és a csúcsok szóhalmazának elemszámáról tájékoztat. Ez az osztály is

NWNetworkAxiomStructure

példány segítségével

tölti fel

a

buildIterObserverPanel függvény által felépített felületet. Közös a három fent bemutatott osztály működésében, hogy mindegyik az NWObserverPanel valamely mezőjéből nyeri a használt információkat, és mindhárom JScrollPane „csúszkát” alkalmaz arra az esetre, ha az adatok nem férnének ki a nem túl széles felületre.

34. ábra NWObserverPanel osztálydiagramja

62

35. ábra NWPropertyObserver osztálydiagramja

36. ábra NWRoadObserver osztálydiagramja

63

37. ábra NWIterationObserver osztálydiagramja

3.4.3.7 Az „NWPropertyEditor” és részei Az „NWPropertyEditor” osztály nyújtja a kezelő felületnek azt a részét, ahol a felhasználó új hálózatot tud létrehozni, vagy egy meglévőt tud módosítani. Ez a panel a program ablak bal oldalán helyezkedik el, de csak akkor látható, ha éppen szükség van rá, vagyis ha folyamatban van egy új hálózat tervezése. Két részből áll a szerkesztő: az első része az NWNetworkPropertyEditor osztály, mellyel a hálózat alap tulajdonságait állíthatjuk be, a második része pedig az NWNodePropertyEditor, mely csúcsonként válogatva ad beviteli mezőket a kezdőaxiómák és a morfizmusok beállítására. Az NWNetworkPropertyEditor a panel felső részében található, ez jelenik meg először, amikor láthatóvá válik a szerkesztő. Függően a szerkesztés céljától az NWPropertyEditor addNetworkPropertyEditorForCreation vagy az addNetworkPropertyEditorForModification függvénye hozza létre és helyezi el, majd ez után helyükre kerülnek a panel alján a gombok is: a „Done” gomb és a „Cancel” gomb, melyek actionCommand tulajdonságát figyelő függvény az NWFrame osztályban található. A bemeneti mezők kitöltése után a felhasználó a „Done” gombra kattint, ekkor lefut a checkCorrectionOfInput függvény, és amennyiben helyesen voltak kitöltve az adatok, akkor helyére kerül a NodePropertyEditor példány, és meghívódik

az

NWNodePropertyEditor

osztálynak

vagy

a

64

buildEditorForCreation vagy pedig a buildEditorForModification függvénye, beállítástól függően. Ha „Egyéni Trigger” beállítást választott a felhasználó, akkor ez előtt még megjelenik egy NWTriggerSetupDialog példány, aminek az input mezőjét kitöltve jut tovább a felhasználó az NWNodePropertyEditor kitöltéséhez. Ha itt is kitöltésre kerültek a bemeneti mezők, akkor ismét a „Done” gombra kattintva elkészül az NWNetworkStructureFactory segítségével egy új NWNetworkStructure példány, melyből közvetlenül ez után legyártódik egy hálózat objektum, és hozzáadódik a rendszer megfelelő tárolóihoz. Ha a folyamat bármely pontján hiba merül fel, arról felugró ablak tájékoztatja a felhasználót, és utasítja az adatok helyes kitöltésére.

38. ábra NWPropertyEditor osztálydiagramja

65

39. ábra NWNetworkPropertyEditor osztálydiagramja

40. ábra NWNodePropertyEditor osztálydiagramja

3.4.3.8 Az „NWComputation” osztály és részei Az NWSystemLogic osztály computeNetwork függvényének a grafikus felületen való használata olyan komplex feladat, hogy ezt nem egy, hanem három osztály végzi: az NWComputation, az NWComputingSwingWorker és az NWComputingDialog. Az NWComputingDialog egy JDialog ablak, mely információkat közöl a számítás állapotáról szöveges módon, és egy JProgressBar segítségével. 66

Az NWComputingSwingWorker osztályra két okból van szükség: az első, hogy meglegyen a lehetőség a számítás idő előtti leállítására, a másik, hogy megfelelően

működjön

az

NWComputingDialog

osztályban

elhelyezett

JProgressBar. Mindkét probléma megoldására tökéletesen elegendő lenne egy párhuzamosan futó programszál, azonban egy közönséges Thread mégsem megfelelő a célra. Ennek oka az, hogy a számítás végeztével a számítás eredménye megjelenik a rendszerlogikában és a grafikus felületen is, amihez mindkét helyen módosításokat kellene végezni a szálnak. Ez azonban nem lehetséges közönséges Thread-del, ugyanis a Java Swing függvénykönyvtára nem „thread safe”, ezért a program megjósolhatatlan és furcsa viselkedéseket produkálna, ha sima Thread használatával oldanánk meg ezt a feladatot. Erre a célra egy módosított SwingWorker objektumot használ a szoftver: az NWComputingSwingWorker osztályt. Ez az osztály azért fontos, mert külön képes kezelni az event dispatch thread programszálat, ami viszont „thread-safe” módon képes módosításokat végezni a grafikus felületen. Az általános számítási eljárás a doInBackground függvény törzsében zajlik egy átlagos Thread segítségével, a grafikus felület módosításai azonban már a done metódusban történnek, ami a fent említett biztonságos szálat alkalmazza. Az NWComputation osztály hangolja össze a másik két osztályt, hogy a számítás biztonságosan, zökkenőmentesen és teljesen automatikusan elvégződjön. Ehhez nem kell mást tenni, mint megadni neki konstruktorban a számítandó hálózatok azonosítóit, és a kiszámítani kívánt iterációk darabszámát, végül pedig elindítani a számítást az execute metódussal.

67

41. ábra NWComputation osztálydiagramja

42. ábra NWComputingSwingWorker osztálydiagramja

43. ábra NWComputingDialog osztálydiagramja

68

3.4.3.9 Az „NWStringPopulationLineChart” osztály Hálózatok szópopulációjának a diagramon való szemléltetésére készült az „NWStringPopulationLineChart” osztály. Lényegében egy JDialog ablakról van szó, mely a JFreeChart szabad forráskódú Java alapú keretrendszerben rejlő lehetőségeket használja ki, hogy szemléletes vonal diagramokat készítsen. Az osztály konstruktorában attól függően, hogy van-e az NWComparePanel példányon összehasonlított hálózat meghívódik vagy a createForDoubleNetwork vagy pedig a createForSingleNetwork függvény, melyek létrehozzák és beállítják a JFreeChart adathalmazait, majd pedig hozzáadják a „dialog ablak” központi paneljéhez a diagramot, hogy megjelenhessen a képernyőn.

44. ábra: NWStringPopulationChart osztálydiagramja

3.4.3.10 Az „NWAboutDialog” osztály A program névjegyének a megjelenítését végző osztály. Egy JDialog ablakban mutatja a program nevét, tudatja, hogy egy szakdolgozat része a szoftver, és a szakdolgozat szerzőjének az elérhetőségét is megjeleníti. Bezárásához az ablak jobb alsó sarkában elhelyezett „OK” gombra kell kattintani, ekkor meghívódik a JDialog osztály dispose metódusa, és az ablak eltűnik.

69

45. ábra: NWAboutDialog osztálydiagramja

3.5 Tesztelés 3.5.1 Tesztelés használatai esetek alapján Menü és Eszköztár: 

„New”, „Delete”, „Modify”, „Close”, „Compare”, „String Population Chart” menüpontok kiválasztása, ha van megnyitott hálózat;



„New”, „Delete”, „Modify”, „Close”, „Compare”, "String Population Chart" menüpontok kiválasztása, ha nincs megnyitott hálózat;



„Open” művelettel hálózat struktúra fájl megnyitása;



azonos nevű menü és eszköztár elemek műveleteinek az egyezésének a vizsgálata.

„Megfigyelő” panel: 

lapfülek között váltás;



csúszkák ellenőrzése, amikor nem fér ki nélküle az információ;



hálózat tulajdonságainak összehasonlítása a struktúra fájlal;



kommunikált szavak összehasonlítása az állapot fájlal.

„Tulajdonság szerkesztő” panel: 

Új hálózat létrehozása: o sablon hálózat azonosítóval továbblépés; o üres hálózati azonosítóval továbblépés; o nulla hálózat mérettel továbblépés; 70

o negatív hálózat mérettel továbblépés; o pozitív hálózatmérettel továbblépés; o nulla ábécé mérettel továbblépés; o negatív ábécé mérettel továbblépés; o páratlan ábécé mérettel továbblépés; o páros ábécé mérettel továbblépés; o üres kezdőaxiómával továbblépés; o választott „trigger” szerint rossz kezdőaxiómával továbblépés; o választott „trigger” szerint jó kezdőaxiómával továbblépés; o ábécében nem szereplő betű használata; o szóközök elhagyása morfizmus szabály megadásánál; o üres morfizmus szabály megadása. 

Megnyitott hálózat módosítása: o üres hálózati azonosítóval továbblépés; o üres kezdőaxiómával továbblépés; o választott „trigger” szerint rossz kezdőaxiómával továbblépés; o választott „trigger” szerint jó kezdőaxiómával továbblépés; o ábécében nem szereplő betű használata; o szóközök elhagyása morfizmus szabály megadásánál; o üres morfizmus szabály megadása.

„Számításvezérlő” panel: 

számítás indítása negatív számmal;



számítás indítása inputként az „alma” szóval;



számítás indítása után „Megszakítás” gombbal leállítása a számításnak;



számítás indítása után „Leállítás kényszerítése” gombbal történő leállítás;



számítás indítása után „Megszakítás” gomb megnyomása és az automatikus leállás között „Leállítás kényszerítése” gomb megnyomása;



ugrás művelet indítása negatív számmal;



ugrás művelet indítása inputként az „alma” szóval;



ugrás művelet indítása kiszámított iteráció számtól nagyobb számmal;



ugrás művelet indítása kiszámított iteráció számtól kisebb számmal.

„Állapotmegjelenítő” panel: 71



vörössel jelzett és az „Iteráció megfigyelő” panelen látható szavak egyezésének vizsgálata;



összehasonlítás esetén feketével jelzett szavak mindék oldali jelenlétének az ellenőrzése.

Egyéb lehetőségek: 

kikapcsolt számítási naplózás után számítás indítása;



visszakapcsolt számítási naplózás után számítás indítása;



program névjegyének megtekintése;



menüből történő leállítás.

3.5.2 Strukturális tesztelés A következőkben fehér doboz tesztelésnek vetjük alá a szoftvert, mely során azt vizsgáljuk, hogy egy lehetséges futási út során a kívánt eredményeket produkálja-e a program. Miután betöltődött a program kattintsunk a „Open” gombra az eszköztáron, és a megnyíló fájlválasztó ablakban jelöljük ki a network_3.xml fájlt, majd kattintsunk a fájlválasztó ablak „Open” gombjára. Az egérkurzor várakozó állapotba váltása tudatja velünk, hogy a hálózat betöltése folyamatban van, majd rövid idő után meg is jelenik a hálózat azonosítója az „Állapotmegjelenítő” panel első lapfülén, és a bal alsó sarokban lévő „Vezérlőpanel” felső részén, ezen kívül a „Megfigyelő” panelről is eltűnik a díszítő kép, és megjelenik a panel három lapfüle. Az eszköztár jobb oldalán tudatja velünk a rendszer, hogy a „network_3” azonosítóval rendelkező hálózat sikeresen betöltődött a memóriába. Az „Állapotmegjelenítő” panelen láthatók a kezdeti iterációban jellemző szóhalmazok, vagyis a „Node id: 0” felirat alatt az a1 szó, a „Node id: 1” alatt pedig a második csúcshoz tartozó kezdőaxióma: az a1 a2 b3 szó. Látható, hogy az „Previous” gomb inaktív, ami logikus, mert a kezdeti állapot előtt nincs semmilyen iteráció, amit be lehetne tölteni, így kattintsunk a „Next” gombra. Az első iteráció állapotán – hogyha a kezdeti állapotot nulladik iterációnak fogjuk fel – látszik, hogy az iterációban kommunikáció történt: az „1” azonosítóval rendelkező csúcs szóhalmazában a b1 b2 a3^3 szó piros színnel van feltüntetve, és látható a „0” azonosítóval 72

rendelkező csúcs szóhalmazában is, ahol eggyel több elem látható, mint az előző iterációban. Ez azt jelenti, hogy megtörtént a számítás végén a kommunikáció, és így eggyel növekedett az első – vagyis „0” azonosítóval rendelkező – csúcs szavainak a száma. Ezt ellenőrizzük le a „Megfigyelő” panel erre a célra létrehozott lapfülén is: válasszuk az „Iteration” nevű fület, és láthatjuk, hogy ugyan az első csúcs nem kommunikált az iterációban semmilyen szót, de a második csúcs igen, méghozzá a b1 b2 a3^3 szót. Ellenőrizzük az „Jump to” művelet helyes működését: írjunk be az „Jump to” gomb mellett található beviteli mezőbe egy akkora számot, ami nagyobb, mint a hálózatban utolsónak kiszámított iteráció száma – amit a bal alsó sarokban található információs panelen láthatunk. A 999 szám megfelelő lesz, ezt beírva, és megnyomva a gombot felugró ablakban kapunk tájékoztatást arról, hogy ennek az iterációnak a betöltéséhez számításra van szükség. Ez után próbáljunk meg egy olyan számot, amihez tartozik kiszámított iteráció, például a 29-es szám ilyen. Beírva és a gombra kattintva látható, hogy változás történt az „Állapotmegjelenítő” panelen: betöltődött az iteráció. Az első csúcs szóhalmazában hét szó található, és ebben az iterációban is történt kommunikáció. A második csúcs szóhalmaza még mindig egy szóból áll, ez azért van, mert a 29. iterációig az első csúcs nem kommunikált egy szót sem. Ez triviális, hiszen, ha megvizsgáljuk a „Megfigyelő” panel „Properties” lapfülén az első csúcshoz tartozó szabályokat jól látszik, hogy ez a csúcs minden betűt a1 betűre ír át, így ebben a csúcsban sohasem fog a „trigger” bekapcsolni (a) protokoll esetén. Ezt könnyen ellenőrizhetjük, ha visszalépünk a kezdeti állapotba, és egyesével lépkedünk el a 29. iterációig a „Next” gomb segítségével: valóban nincs kommunikáció az első csúcsban. Most vizsgáljuk meg a hálózat csúcsainak a Watson-Crick útját: válasszuk a „Megfigyelő” panel „Road” lapfülét, és keressük meg a „Node id: 1” alatti részt. Látható, hogy a hálózat viselkedése általános, vagyis nem fekete lyuk, és nem is fehér lyuk, azaz a számítások során volt olyan iteráció, amikor küldött szót, de nem mindegyikben. Ha megkeressük a biteket tízes csoportokra tördelő „dobozok” közül a harmadikat, akkor látszik, hogy a 29. pozícióban lévő bit „1”, azaz ebben a számítási lépésben ez a csúcs kommunikált legalább egy szót. Esetünkben pontosan egyet, erről az „Iteration” lapfülön meg is győződhetünk: a kommunikált szó az a1 a2^27 b3^27. Továbbá látszik a „Road” fülön még az is, hogy az első csúcs nem

73

kommunikált eddig az iterációig – és utána sem – szavakat, ezért a kommunikációs viselkedése fekete lyuk. Próbáljuk ki a hálózat számításának a műveletét: először adjunk meg helytelen bemenetet, például a -1 számot. Ekkor felugró ablakban kapunk hibaüzenetet, hogy a bemenet helytelen, adjunk meg pozitív egész számot. Írjuk be a 10-es számot, és kattintsunk a „Compute” gombra. A „Számítási ablak” jelenik meg, melyben az állapotjelző csíkon figyelemmel követhető a számítás állapota. Várjuk meg, hogy befejeződjön a számítás, majd indítsunk egy újat 100 iterációra. Miután megkezdődött a számítás, válasszuk az „Interrupt” gombot, ekkor a szoftver a türelmünket kéri, amíg a jelenleg számítás alatt lévő iteráció befejeződik, utána az ablak bezárul. Az „Options” menüpont „Compute Log Off” menüpontját kiválasztva ismét futtassunk egy számítást, hogy meggyőződjünk róla, hogy tényleg gyorsabban futott le, mint amikor be volt kapcsolva a számítási naplózás. Most nyissunk meg egy másik hálózatot is, hogy az összehasonlítást ellenőrizhessük: válasszuk a network3_patu40.xml

hálózat struktúra fájlt.

Miután megnyílt a hálózat kattintsunk az „Compare” gombra az eszköztáron, majd válasszuk ki az újonnan megnyitott hálózatot. Néhány iterációnyi léptetés után meggyőződhetünk róla, hogy a szószínezés megfelelően működik, a kommunikált szavak pirosak, a csak bal oldalon látható szava zöldek, a csak jobb oldaliak kékek, míg a közös szavak fekete színnek vannak feltüntetve. Ez után válaszuk a „String Population Chart” gombot az eszköztáron, aminek a megnyomása után megjelenik a kiválasztott és az összehasonlított hálózatok szópopulációjának a változása vonalgrafikonon szemléltetve. Zárjuk be, majd válasszuk az „Options” menü „About” menüpontját, aminek a hatására azonnal megjelenik a program névjegye. Zárjuk be a névjegyet, majd a „File” menü „Exit” menüpontjával állítsuk le a program futását.

74

4. Összegzés Sikerült olyan alapkoncepciót és szoftver létrehozni, mely segítségével hatékonyan lehet a szimulált Watson-Crick D0L rendszerek hálózatainak különböző tulajdonságait vizsgálni, és ezzel válaszokat vagy megerősítéseket nyerni bizonyos kérdésekben. Ezzel együtt eddig fel nem merült kérdések és kutatási irányok megjelenése is lehetséges. A létrehozott program az „egyéni trigger” funkció miatt alkalmas olyan hálózatok vizsgálatára is, ahol az átfordulási feltétel általánosabb formában adott. Mivel a program Java nyelven íródott, ezért kis változtatásokkal a legkülönbözőbb rendszereken nyílik lehetőség a futtatására, mely a nagyobb memória és számítási kapacitás lehetősége miatt megnyitja a kaput a nagyobb „string-számmal” és szóhosszal működő hálózatok kutatása felé is. A további főbb fejlesztési irányvonalak a következők: 

Számítási

algoritmus

optimalizálása

egyszerre

több

párhuzamos

programszálon való futtatásra, hogy egy nagyobb számítási kapacitású rendszerben – például egy felhőben – még nagyobb hatásfokkal működjön a számítási eljárás. 

Felhasználói felület nagyobb hálózatokhoz való optimalizálása, több monitoros megjelenítés támogatása.



Szóhalmazok új kimeneti formázása, mely nyomtatáshoz megfelelő formában áttekinthetően helyezi el a szavakat és a hálózatok csúcsait, valamint programból való nyomtatás lehetőségének az implementációja.

75

Irodalomjegyzék [1] L. M. Adleman, Molecular computation of solutions to combinatorical problems. Science, 266 (1994), 1021-1024. [2] G. Rozenberg, A. Salomaa (ed.), Handbook of Formal Languages, Vol. 1.3. Springer-Verlag, Berlin, Heidelberg, New York (1997). [3] V. Mihalache, A. Salomaa, Watson-Crick D0L Systems. EATCS Bulletin 62 (1997), 160-175. [4] J. Csima, E. Csuhaj-Varjú, A. Salomaa, Power and size of extended Watson-Crick L systems. Theorical Computer Science 290 (2003) 1665-1678 [5] E. Csuhaj-Varjú, A. Salomaa, Networks of Watson-Crick D0L systems, TUCS Technical Report No. 419, Turku Centre of Computer Science, 2001. [6] E. Csuhaj-Varjú, A. Salomaa, Networks of Watson-Crick D0L systems, In: Words, Languages & Combinatorics III. Proceedings of the Internatonal Colloquium, Kyoto, Japan, March 14-21, 2000. Ed. by M. Ito and T. Imaoka, World Scientific Publishing Co., Singapore, 2003, 134-149. [7] Java (programming language). Wikipedia the free encyclopedia.[ONLINE] [Hivatkozva: 2013.11.22]

http://en.wikipedia.org/wiki/Java_(programming_language) [8] JFreeChart. [ONLINE] [Hivatkozva: 2013.11.22] http://www.jfree.org/jfreechart/ [9] What are the system requirements for Java 7? [ONLINE] [Hivatkozva: 2013.11.22] http://www.java.com/en/download/help/sysreq.xml

76