{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## 5. Állandó fázisú pont módszere, SPPMethod\n", "\n", "Ez a módszer alapjaiban kissé különbözik a többitől. Az előzőleg leírt globális metódusok, mint domain átváltás, kivágás, stb. itt is működnek, de másképpen kell kezelni őket. *Megjegyezném, hogy mivel ez a módszer interaktív elemet tartalmaz, az egyelőre csak Jupyter Notebook-ban stabil.*" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import pysprint as ps" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Példaként a korábban már bemutatott `ps.Generator` segítségével generálni fogok egy sorozat interferogramot, majd azon bemutatom a kiértékelés menetét. Valós méréseknél teljesen hasonlóképpen végezhető a kiértékelés. A legegyszerűbb módszer, hogy különböző karok közti időbeli késleltetésnél generáljunk és elmentsük azokat az alábbi cellában látható. A megkülönböztethetőség miatt minden fájlt a hozzá tartozó karok közti időbeli késleltetésnek megfelelően nevezem el." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "for delay in range(-200, 201, 50):\n", " g = ps.Generator(1, 3, 2, delay, GDD=400, TOD=-500, normalize=True)\n", " g.generate_freq()\n", " np.savetxt(f'{delay}.txt', np.transpose([g.x, g.y]), delimiter=',')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A kód lefuttatásával a munkafüzet környtárában megjelent 7 új txt fájl. \n", "\n", "Ehhez a kiértékelési módszerhez először fel kell építeni egy listát a felhasználandó interferogramok fájlneveivel. Ezt manuálisan is megtehetjük, itt ezt elkerülve egy rövidítést fogok használni." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "ifg_files = [f\"{delay}.txt\" for delay in range(-200, 201, 50)]" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['-200.txt', '-150.txt', '-100.txt', '-50.txt', '0.txt', '50.txt', '100.txt', '150.txt', '200.txt']\n" ] } ], "source": [ "print(ifg_files)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ha nem hasonló sémára épülnek a felhasználandó fájlok nevei, akkor természetesen a fenti trükk nem működik és egyenként kell beírnunk őket. Miután definiáltuk a fájlneveket a következő lépés a\n", "```python\n", "ps.SPPMethod(ifg_names, sam_names=None, ref_names=None, **kwargs)\n", "```\n", "meghívása:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "myspp = ps.SPPMethod(ifg_files, decimal=\".\", sep=\",\", skiprows=0, meta_len=0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A `**kwargs` keyword argumentumok itt elfogadják a korábban már bemutatott `parse_raw` funkció argumentumait (a kódban belül azt is hívja meg egyesével minden interferogramon), hiszen a fájlok sémáját itt is fontos megadni a helyes betöltéshez. A tárgy- és referencianyaláb spektrumai természetesen opcionális argumentumok, mi dönthetjük el, hogy normáljuk-e az interferogramokat.\n", "\n", "Az `SPPMethod` objektum először ellenőrzi, hogy a listában lévő fájlnevek valóban léteznek-e, és ha nem, akkor hibával tér vissza. Az `SPPMethod`-nak vannak további metódusai, ilyen pl. a `len(..)`, vagy az `SPPMethod.info`. Az első visszaadja, hogy hány interferogram van jelenleg az objektumban (ez jelen esetben 9), a második pedig a kiértékelés során mutatja majd, hogy hány interferogramból rögzítettünk információt (ez jelenleg 0/9). Később talán `append` (ilyen már van a 0.12.5 verziótól), `insert` és `delete` metódusokat is beépítek." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "9\n" ] } ], "source": [ "print(len(myspp))" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Progress: 0/9\n" ] } ], "source": [ "print(myspp.info)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Az SPPMethod objektum listaszerűen viselkedik: lehet indexelni is. Mivel benne 9 darab interferogram van, ezért egy ilyen indexelés egy `ps.Dataset` objektumot ad vissza. Ez az alapja minden kiértékelési módszernek, így ez ismeri a korábban bemutatott metódusokat. Tegyük fel, hogy a 3. interferogram adatait ki szeretnénk iratni, és szeretnénk megkapni az y értékeit `np.ndarray`-ként. Ekkor a 2 indexet használva (mivel itt is 0-tól indul a számozás):" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dataset\n", "----------\n", "Parameters\n", "----------\n", "Datapoints: 12559\n", "Predicted domain: frequency\n", "Range: from 0.99998 to 3.00000 PHz\n", "Normalized: False\n", "Delay value: Not given\n", "SPP position(s): Not given\n", "----------------------------\n", "Metadata extracted from file\n", "----------------------------\n", "{}\n" ] } ], "source": [ "# a harmadik interferogram adatainak kiíratása\n", "print(myspp[2])" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[4.22567237e-08 4.23424876e-08 4.24102757e-08 ... 4.41394357e-08\n", " 4.30227521e-08 4.18888151e-08]\n", "\n" ] } ], "source": [ "# a harmadik interferogram y értékeinek kinyerése, mint np.array\n", "y_ertekek = myspp[2].data.y.values\n", "print(y_ertekek)\n", "print(type(y_ertekek))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Újra hangsúlyozom, minden eddig bemutatott metódus ezeken a kvázi listaelemeken is működik, köztük a `chdomain`, vagy `slice` is. Ezt használjuk ki a kiértékeléshez egy *for* ciklusban. A kiértékeléshez a definiált `SPPMethod`-on meg kell hívni egy for ciklust. Ez végigfut a benne lévő összes interferogramon. Azt, hogy mit akarunk csinálni adott interferogrammal, azt a cikluson belül tudjuk megadni. Az alapvető séma a következő:\n", "
\n",
    "for ifg in myspp:\n",
    "    - előfeldolgozása az adott interferogramnak\n",
    "    - az interaktív SPP Panel megnyitása és adatok rögzítése\n",
    "    \n",
    "- a calculate metódus meghívása a cikluson kívül(!)\n",
    "
\n", "\n", "Ez kód formájában az alábbi cellában látható. Itt külön jelöltem, hogy melyik rész meddig tart." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle GD = -0.60975 ± 0.00000 fs^1$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle GDD = -391.93908 ± 20.48631 fs^2$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle TOD = 277.28636 ± 226.70828 fs^3$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# az interaktív számításokat fontos a with blokkon belülre írni\n", "\n", "with ps.interactive():\n", "\n", " for ifg in myspp:\n", "\n", " # -----------------------------------Előfeldolgozás-----------------------------------------\n", " # Ha valós mérésünk van, érdemes valamilyen módon kiíratni a kommentet,\n", " # ami az interferogram fájlban van, hogy meg tudjuk állapítani milyen késleltetésnél készült.\n", " # Jelen esetben ennek nincs értelme, mivel a szimulált fájlokkal dolgozom.\n", " # Ezt legegyszerűbben az alábbi sorral tehetnénk meg: \n", " # print(ifg.meta['comment'])\n", " # vagy esetleg a teljes metaadatok kiíratása:\n", " # print(ifg.meta)\n", "\n", " # Ha hullámhossztartományban vagyunk, először át kell váltani.\n", " # Én frekvenciatartományban szimuláltam, ezért itt kihagyom. Ha szükség van rá a\n", " # következő sort kell használni.\n", " # ifg.chdomain() \n", "\n", " # Pl. 1.2 PHz alatti körfrekvenciaértékek kivágása. Mivel nem adtam meg stop értéket, így a felső\n", " # határt érintetlenül hagyná, ha futtatnám. Nyilván ez is opcionális.\n", " # ifg.slice(start=1.2)\n", "\n", " # -----------------------------Az interaktív panel megnyitása-------------------------------\n", " ifg.open_SPP_panel()\n", "\n", "# ---------------------------------A ciklus utáni rész------------------------------------------\n", "# A cikluson kívül a save_data metódus meghívása, hogy elmentsük a beírt adatainkat fájlba is.\n", "# Ez természetesen opcionális, de annak érdekében, hogy biztosan ne veszítsünk adatot érdemes ezt is elvégezni.\n", "myspp.save_data('spp.txt')\n", "\n", "\n", "# a cikluson kívül meghívjuk a calculate függvényt\n", "myspp.calculate(reference_point=2, order=3);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A magyarázatok nélkül szimulált esetben az egész kód az alábbi, összesen 8 sorra egyszerűsödik. Valós mérés esetén néhány előfeldolgozási lépés és kiíratás természetesen még hozzáadódhat ehhez.\n", "\n", "```python\n", "import pysprint as ps\n", "\n", "ifg_files = [f\"{delay}.txt\" for delay in range(-200, 201, 50)]\n", "\n", "s = ps.SPPMethod(ifg_files, decimal=\".\", sep=\",\", skiprows=0, meta_len=0)\n", "\n", "with ps.interactive():\n", " for ifg in s:\n", " ifg.open_SPP_panel()\n", " \n", "s.save_data('spp.txt')\n", "s.calculate(reference_point=2, order=2, show_graph=True)\n", "```\n", "Miután a számolást már elvégezte a program, akkor elérhetővé válik rajta a `GD` property. Ez az illesztett görbét reprezentálja, típusa `ps.core.phase.Phase`. Bővebben erről a `Phase` leírásában." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "myspp.GD" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 5.1 Számolás nyers adatokból\n", "Mivel az `spp.txt` fájlba elmentettük az bevitt adatokat, azokból egyszerűen lehet újraszámolni az illesztést. Töltsük be `np.loadtxt` segítségével, majd használjuk a `ps.SPPMethod.calculate_from_raw` függvényt." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle GD = -0.60975 ± 0.00000 fs^1$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle GDD = -391.93908 ± 20.48631 fs^2$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle TOD = 277.28636 ± 226.70828 fs^3$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "delay, position = np.loadtxt('spp.txt', delimiter=',', unpack=True)\n", "\n", "myspp.calculate_from_raw(delay, position, reference_point=2, order=3);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Az előbbi esetben látható, hogy ugyan azt az eredményt kaptuk, mint előzőleg. Ez akkor is hasznos lehet, ha már megvannak a leolvasott SPP pozícióink a hozzá tartozó késleltetésekkel és csak a számolást akarjuk elvégezni. Ekkor még létre sem kell hozni egy új objektumot, csak meghívhatjuk a függvényt következő módon:\n" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle GD = 1.99335 ± 0.00000 fs^1$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle GDD = 0.00038 ± 0.00006 fs^2$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle TOD = 0.00000 ± 0.00000 fs^3$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# ehhez beírtam egy teljesen véletlenszerű adatsort\n", "delay_minta = [-100, 200, 500, 700, 900]\n", "position_minta = [2, 2.1, 2.3, 2.45, 2.6]\n", "\n", "ps.SPPMethod.calculate_from_raw(delay_minta, position_minta, reference_point=2, order=3);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**FONTOS MEGJEGYZÉS:**\n", "\n", "Az `order` argumentum a program során mindig a keresett diszperzió rendjét adja meg." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 5.2 Számolás egy további módon" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mivel továbbra is ugyan ezekkel az adatsorokkal és a `myspp` objektummal dolgozom, most törlöm az összes rögzített adatot belőlük. Ehhez a `SPPMethod.flush` függvényt használom. (Valószínűleg ez a felhasználónak kevésszer szükséges, de elérhető.)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "myspp.flush()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Korábban már észrevehettük, hogy a kiíratás során - legyen bármilyen módszerről is szó - megjelentek olyan sorok is, hogy `Delay value: Not given` és `SPP position(s): Not given`. Például a `myspp` első interferogramja esetén most ez a helyzet:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dataset\n", "----------\n", "Parameters\n", "----------\n", "Datapoints: 12559\n", "Predicted domain: frequency\n", "Range: from 0.99998 to 3.00000 PHz\n", "Normalized: False\n", "Delay value: Not given\n", "SPP position(s): Not given\n", "----------------------------\n", "Metadata extracted from file\n", "----------------------------\n", "{}\n" ] } ], "source": [ "print(myspp[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ahogyan a `Dataset` leírásában már szerepelt, lehetőségünk van megadni a betöltött interferogramokon az SPP módszerhez szükséges adatokat. Ekkor a `ps.SPPMethod.calculate_from_ifg(ifgs, reference_point, order)` függvénnyel kiértékelhetjük a benne lévő interferogramokat a következő módon:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "# kicsomagolok öt interferogramot a generált 7 közül\n", "\n", "elso_ifg = myspp[0]\n", "masodik_ifg = myspp[1]\n", "harmadik_ifg = myspp[2]\n", "negyedik_ifg = myspp[3]\n", "otodik_ifg = myspp[4]" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "# beállítok rájuk véletlenszerűen SPP adatokat\n", "\n", "elso_ifg.delay = 0\n", "elso_ifg.positions = 2\n", "\n", "masodik_ifg.delay = 100\n", "masodik_ifg.positions = 2\n", "\n", "harmadik_ifg.delay = 150\n", "harmadik_ifg.positions = 1.6\n", "\n", "negyedik_ifg.delay = 200\n", "negyedik_ifg.positions = 1.2\n", "\n", "otodik_ifg.delay = 250\n", "otodik_ifg.positions = 1, 3, 1.2\n", "\n", "\n", "# listába teszem őket\n", "ifgs = [elso_ifg, masodik_ifg, harmadik_ifg, negyedik_ifg, otodik_ifg]" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle GD = 71.99708 ± 0.00000 fs^1$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle GDD = -19.90037 ± 30.07946 fs^2$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle TOD = 381.52310 ± 94.83666 fs^3$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# meghívom a calculate_from_ifg függvényt\n", "ps.SPPMethod.calculate_from_ifg(ifgs, reference_point=2, order=3);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ez úgy lehet hasznos, hogy amikor más módszerrel több interferogramot is kiértékelünk egymás után, csak rögzítjük az SPP adatokat is, aztán a program ezekből egyenként összegyűjti a szükséges információt a kiértékeléshez, majd abból számol." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 5.3 Az SPPMethod működéséről mélyebben, cache, callbacks, from_log\n", "\n", "\n", "Az `SPPMethod` alapvető működését az adatok rögzítése közben az alábbi ábra mutatja.\n", "\n", "![SPP működése](spp_diagram.svg)\n", "\n", "A hurok az `SPPMethod`-ból indul, ahol a használandó fájlok neveit, betöltési adatokat, stb. adunk meg. Ezen a ponton még semmilyen számolás és betöltés nem történik. Ezután az `SPPMethod` bármely elemének hívására egy `Dataset` objektum jön létre. Ezen megnyitható az `SPPEditor`, amiben az állandó fázisú pont(ok) helyét és a karok közti késleltetést lehet megadni. Hitelesítés után az SPP-vel kapcsolatos információk az interaktív szerkesztőből visszakerülnek a létrehozott `Dataset` objektumba és ott rögzítődnek. Minden így létrejött `Dataset` objektum kapcsolva van az `SPPMethod`-hoz, amiből felépült, így amikor megváltozik egy SPP-vel kapcsolatos adat, az egyből megváltozik az `SPPMetod`-ban is. A `Registry` gondoskodik arról, hogy minden objektum ami a memóriában van az rögzítődjön, illetve szükség esetén elérhető legyen.\n", "\n", "\n", "**Cache**\n", "\n", "Ha próbálunk elérni egy adott elemet (akár a `for` ciklussal, akár indexelve, vagy egyéb módon), létrejön egy `Dataset` objektum. Ez a `Dataset` objektum miután már egyszer elértük a memóriában marad és megtart minden rajta végrehajtott változtatást, beállítást. Alapértelmezetten *128 db* interferogram marad a memóriában egyszerre, de ez a határ szükség esetén megváltoztatható. Az éppen aktuálisan a memóriában lévő interferogramok száma (az adott `SPPMethod`-hoz tartozó) a kiíratás során a `Interferograms cached` cellában látható.\n", "\n", "**Callbacks**\n", "\n", "A fenti ábrán a ciklus utolsó lépése során (ahol a `Dataset` átadja az SPP-vel kapcsolatos adatait a `SPPMethod`-nak) lehetőség van további ún. *callback* függvények meghívására. Egy ilyen beépített callback függvény a `pysprint.eager_executor`. Ez arra használható, hogy minden egyes SPP-vel kapcsolatos adat rögzítése/változtatása után a program azonnal kiszámolja az éppen meglévő adatokból a diszperziót. A korábbiakhoz teljesen hasonlóan kell eljárnunk, csupán a `callback` argumentumot kell megadnunk kiegészítésként. Itt a kötelező argumentumokon túl megadtam a `logfile` és `verbosity` értékeit is: ez minden lépés során a `\"mylog.log\"` fájlba el fogja menteni az adott illesztés eredményeit és egyéb információkat, továbbá a `verbosity=1` miatt a rögzített adatsort is. Ezzel akár könnyen nyomon követhető a kiértékelés menete." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "# a folyamatos kiértékeléshez szükséges callback függvény importálása\n", "from pysprint import eager_executor\n", "\n", "myspp2 = ps.SPPMethod(\n", " ifg_files,\n", " decimal=\".\",\n", " sep=\",\",\n", " skiprows=0,\n", " meta_len=0,\n", " callback=eager_executor(reference_point=2, order=3, logfile=\"mylog.log\", verbosity=1)\n", ")" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", " SPPMethod\n", "
Interferograms accumulated 9
Interferograms cached 0
Data recorded from 0
Eagerly calculating True
\n", " " ], "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "myspp2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ekkor láthatjuk, hogy az `Eagerly calculating` már `True` értékre változik." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Természetesen a program csak értelmes esetekben fogja elvégezni a számolást (pl. szükséges, hogy az adatpontok száma nagyobb legyen, mint az illesztés rendje ). A teljesség kedvéért megemlítendő, hogy könnyen írható akár saját callback függvény is. Futtassuk le az újonnan létrehozott `myspp2`-n a már megismert *for* ciklust:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle GD = 49.67951 ± 0.00000 fs^1$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle GDD = -380.81053 ± 16.67232 fs^2$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle TOD = 402.32343 ± 179.81894 fs^3$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with ps.interactive():\n", " for ifg in myspp2:\n", " ifg.open_SPP_panel()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A fenti cella futtatása közben - miután rögzítettünk elég adatot - megjelentek az eredmények, és minden új adatpont hozzáadása esetén frissültek is. Az adatok rögzítését itt ugyan az interaktív felületet használva végeztem, de akár kódban is megtehető: a `myspp` elemein kell az `delay` és `positions` argumentumokat beállítani, és minden új adat hozzáadásánál újra fogja számolni a program. Az előző számolásom közben készült logfile a következő:" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "---------------------------------------------------------------------------------------\n", "Date: 2020-12-30 09:35:32.569563\n", "Datapoints used: 3\n", "R^2: 1.00000\n", "Results:\n", "GD = 50.00000 fs^1\n", "GDD = -378.39901 fs^2\n", "TOD = 368.22696 fs^3\n", "Values:\n", "x: [2.31146, 2.14193, 1.99999]\n", "y: [-50., 0., 50.]\n", "---------------------------------------------------------------------------------------\n", "Date: 2020-12-30 09:35:36.344006\n", "Datapoints used: 4\n", "R^2: 0.99987\n", "Results:\n", "GD = 50.92928 fs^1\n", "GDD = -398.34978 fs^2\n", "TOD = 481.48866 fs^3\n", "Values:\n", "x: [2.31146, 2.14193, 1.99999, 1.88565]\n", "y: [-50., 0., 50., 100.]\n", "---------------------------------------------------------------------------------------\n", "Date: 2020-12-30 09:35:42.355376\n", "Datapoints used: 5\n", "R^2: 0.99807\n", "Results:\n", "GD = 51.99789 fs^1\n", "GDD = -360.91805 fs^2\n", "TOD = 186.61942 fs^3\n", "Values:\n", "x: [2.31146, 2.14193, 1.99999, 1.88565, 1.73977]\n", "y: [-50., 0., 50., 100., 150.]\n", "---------------------------------------------------------------------------------------\n", "Date: 2020-12-30 09:35:48.140150\n", "Datapoints used: 6\n", "R^2: 0.99455\n", "Results:\n", "GD = 49.67951 fs^1\n", "GDD = -380.81053 fs^2\n", "TOD = 402.32343 fs^3\n", "Values:\n", "x: [2.31146, 2.14193, 1.99999, 1.88565, 1.73977, 1.68063]\n", "y: [-50., 0., 50., 100., 150., 200.]\n", "---------------------------------------------------------------------------------------\n", "Date: 2020-12-30 09:35:50.094888\n", "Datapoints used: 6\n", "R^2: 0.99455\n", "Results:\n", "GD = 49.67951 fs^1\n", "GDD = -380.81053 fs^2\n", "TOD = 402.32343 fs^3\n", "Values:\n", "x: [2.31146, 2.14193, 1.99999, 1.88565, 1.73977, 1.68063]\n", "y: [-50., 0., 50., 100., 150., 200.]\n" ] } ], "source": [ "!type mylog.log" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ebből a fájlból akár be is tölthetjük a benne szerepelő adatokat. Ehhez használjuk a `from_log` konstruktort:" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "spp_checkpoint = ps.SPPMethod.from_log('mylog.log')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ez visszaállította a log fájlban rögzített adatokat. Ezen az objektumon új kiértékelést is végezhetünk, sőt módosíthatjuk a korábban beírt adatokat. Az interferogram értékeit azonban csak ebből a fájlból nem ismerjük, így azok x-y értékek nélkül kerülnek felépítésre. Pl. a visszaállított `spp_checkpoint` első interferogramja:" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "
\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", " MimickedDataset\n", "
\n", " Parameters\n", "
Datapoints 1
Predicted domain frequency
Range min 0.00000 PHz
Range max 0.00000 PHz
Normalized True
Delay value-50.0 fs
SPP position(s)2.31146 PHz
\n", " Metadata\n", "
\n", "
\n", "
" ], "text/plain": [ "" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "spp_checkpoint[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ez egy ún. `MimickedDataset` objektum, amelyen megkötés nélkül módosíthatjuk az SPP-vel kapcsolatos adatokat. Az adatok változtatására továbbra is reagálni fog az `spp_checkpoint`:" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle GD = 49.67961 ± 0.00000 fs^1$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle GDD = -380.80775 ± 16.67256 fs^2$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle TOD = 402.30335 ± 179.82198 fs^3$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "spp_checkpoint.calculate(2, 3);" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle GD = 50.86642 ± 0.00000 fs^1$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle GDD = -407.56908 ± 18.75457 fs^2$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "$\\displaystyle TOD = 178.54695 ± 202.27753 fs^3$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# egy adat megváltoztatása\n", "spp_checkpoint[0].delay = -70\n", "\n", "# újraszámolás már más adatokat ad\n", "spp_checkpoint.calculate(2, 3);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Egy ilyen `MimickedDataset` objektum visszakonvertálható igazi `Dataset` objektummá - amennyiben emlékszünk melyik interferogram fájlhoz tartozott. Ehhez használhatjuk a `to_dataset` függvényt." ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "mydataset = spp_checkpoint[0].to_dataset('-100.txt', parse=True, skiprows=8, meta_len=0, decimal=\".\", sep=\",\")" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "
\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", " Dataset\n", "
\n", " Parameters\n", "
Datapoints 12551
Predicted domain frequency
Range min 0.99998 PHz
Range max 2.99618 PHz
Normalized False
Delay value-70.0 fs
SPP position(s)2.31146 PHz
\n", " Metadata\n", "
\n", "
\n", "
" ], "text/plain": [ "" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mydataset" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Egy egyszerűbb módszer a betöltésre a `from_pattern` konstruktorral történik. Itt egy mintát kell megadnunk, amire a fájlnevek épülnek. Opcionálisan a `mod` argumentummal csoportosíthatjuk őket a megadott modulo szerint (általában a mod=3 lehet hasznos, ekkor ugyanis a karok spektrumaival könnyen csoportosíthatjuk a fájlokat.) Az általam generált fájlokhoz a `\"*.txt\"` mintát használom, illetve a betöltési opciók változatlanok:" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [], "source": [ "spp2 = ps.SPPMethod.from_pattern('*.txt', skiprows=8, meta_len=0, decimal=\".\", sep=\",\" )" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", " SPPMethod\n", "
Interferograms accumulated 9
Interferograms cached 0
Data recorded from 0
Eagerly calculating False
\n", " " ], "text/plain": [ "" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "spp2" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.4" } }, "nbformat": 4, "nbformat_minor": 4 }