{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# **GOLEM MFR tomography**\n", "This notebook loads the camera data from two certical and radial fast cameras on tokamak GOLEM and then performs tomopgraphic inversion using MFR algorithm.\n", "Geometry matrix data are needed - notebook called geometry_matrix.ipynb creates all needed.\n", " \n", "\n", "*Required python libraries for this notebook: numpy, matplotlib,, opencv, tomotok, IPython.display and scipy.ndimage*\n", "________________________________________________" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Code:\n", "Necessary imports:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "tags": [] }, "outputs": [], "source": [ "from typing import Optional\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import cv2 #opencv\n", "import requests\n", "import os, glob\n", "from pathlib import Path\n", "\n", "from tomotok.core.derivative import compute_iso_dmats, compute_aniso_dmats\n", "from tomotok.core.geometry import RegularGrid\n", "from tomotok.core.geometry.io import load_sparse_gmat\n", "from tomotok.core.inversions import CholmodMfr, Mfr, Fixt, CholmodFixt\n", "from scipy.ndimage import gaussian_filter\n", "\n", "from IPython.display import Image\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "shot_no = 45951\n", "FPS = 80000 #camera frame rate\n", "FPMS = FPS * 1e-3 #camera frame rate [1/ms]\n", "\n", "result_folder = Path(\"./results\")\n", "Path(result_folder).mkdir(exist_ok=True)\n", "Path(result_folder / \"data\").mkdir(exist_ok=True)\n", "Path(result_folder / \"graphs\").mkdir(exist_ok=True)\n", "Path(result_folder / \"stats\").mkdir(exist_ok=True)\n", "\n", "frames_folder = Path(\"./frames\")\n", "Path(frames_folder).mkdir(exist_ok=True)\n", "Path(frames_folder / \"vertical\").mkdir(exist_ok=True)\n", "Path(frames_folder / \"radial\").mkdir(exist_ok=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Defined functions:**\n", "Function creates mask for poloidal plane dataset:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "tags": [] }, "outputs": [], "source": [ "def create_mask(grid: RegularGrid, limiter_mask: bool, plasmaradius: Optional[float] = None):\n", " \"\"\"Creates mask, of the same size as grid, of True and False vlaues to define where to compute the reconstructions.\n", "\n", " Args:\n", " grid (RegularGrid): Reconstruction grid.\n", " limiter_mask (bool): True if you want the results up to limiter, False if you want to see results to LCFS.\n", " plasmaradius (float, optional): Radius of plasma (and of the reconstruction domain). If limiter_mask is False, this parameter can be None.\n", "\n", " Returns:\n", " RegularGrid class ndarray of the given grid size, with True values where the reconstrucition will be computed (inside limiter/plasma radius).\n", " \"\"\"\n", " \n", " plasmacentre = 0.40 #minor tokamak radius\n", " chamberradius = 0.1 #chamber radius\n", " \n", " #Limiter and chamber radii definitions\n", " t = np.linspace(0,2*np.pi,100) #t is just a parameter for the curves/circles\n", "\n", " if limiter_mask==True:\n", " #limiter curve definition\n", " r = plasmacentre + plasmaradius*np.sin(t)\n", " z = plasmaradius*np.cos(t)\n", " bdm = grid.is_inside(r, z)\n", " else:\n", " #chamber curve definition\n", " R = plasmacentre + chamberradius*np.sin(t)\n", " Z = chamberradius*np.cos(t)\n", " bdm = grid.is_inside(R, Z)\n", " return bdm" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Function that extracts images from loaded video data:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def imagesfromvideo(minrange:int,maxrange:int):\n", " \"\"\"Extracts single frames from both GOLEM camera data and saves them\n", "\n", " Args:\n", " ver_vid (cv2.VideoCapture): vertical camera data\n", " rad_vid (cv2.VideoCapture): radial camera data\n", " Returns:\n", " \"\"\"\n", " #loads from golem shot website - .mp4\n", " capver=cv2.VideoCapture(f'http://golem.fjfi.cvut.cz/shots/{shot_no}/Diagnostics/FastCameras/Camera_Vertical/Data.mp4')\n", " caprad=cv2.VideoCapture(f'http://golem.fjfi.cvut.cz/shots/{shot_no}/Diagnostics/FastCameras/Camera_Radial/Data.mp4')\n", " i = minrange \n", " \n", " capver.set(1,i)\n", " caprad.set(1,i)\n", " \n", " retver, framever = capver.read(1) \n", " retrad, framerad = caprad.read(1) \n", " while retver and retrad and i < maxrange:\n", " retver, framever = capver.read(1) \n", " retrad, framerad = caprad.read(1) \n", " \n", " #Saving frames\n", " namever = str(frames_folder / \"vertical\" / str(str(i)+'.png'))\n", " cv2.imwrite(namever, framever) \n", " namerad = str(frames_folder / \"radial\" / str(str(i)+'.png'))\n", " cv2.imwrite(namerad, framerad) \n", " i=i+1\n", " capver.release()\n", " caprad.release()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "tags": [] }, "outputs": [], "source": [ "def datafromimage(framenumber:int,channel: int):\n", " \"\"\"Extracts signal (frame given by frame number) from both GOLEM camera frames. \n", "\n", " Args:\n", " framenumber (int): Number of frame which will be extracted\n", " channel (int): color channel to be used 012 BGR\n", "\n", "\n", " Returns:\n", " sig: Signal from given frame in ndarray form.\n", " \"\"\"\n", " namever = str(frames_folder / \"vertical\" / str(str(framenumber)+'.png'))\n", " namerad = str(frames_folder / \"radial\" / str(str(framenumber)+'.png'))\n", "\n", " ogimagerad = cv2.imread(namerad,cv2.IMREAD_UNCHANGED )[:,:,channel] #loading radial image \n", " ogimagever = cv2.imread(namever,cv2.IMREAD_UNCHANGED )[:,:,channel] #loading vertical image\n", "\n", " #THIS MUST BE CHANGED DEPENDING ON THE GEOMETRY MATRIX USED - MUST CONSTRUCT IT FOR EACH ROW DIFFERENTLTY\n", " rowrad = 511 #which radial camera detector row to use for reconstruction\n", " rowver = 511 #which vertical camera detector row to use for reconstruction\n", "\n", " #Discarding obstructed detectors\n", " leftstoprad = 0 #leftmost R camera detector to be used (useful if cameras' view is obstructed on edges, 0 if all detectors see the plasma)\n", " rightstoprad = 1280 #rightmost R camera detector to be used (1280 if all)\n", " totalspanrad = rightstoprad - leftstoprad\n", "\n", " leftstopver = 0 #leftmost V camera detector to be used (useful if cameras' view is obstructed on edges, 0 if all detectors see the plasma)\n", " rightstopver = 1280 #rightmost V camera detector to be used (1280 if all)\n", " totalspanver = rightstopver - leftstopver\n", "\n", " fullheight = 1024 #height of full camera picture in pixels\n", " fullwidth = 1280 #width of full camera picture in pixels\n", " imgheight = np.shape(ogimagerad)[0] #height of loaded image, \n", " imgheighthalf = int((fullheight-imgheight)/2) #where to insert loaded image into 1024 by 1280 array for easier handling of distortion\n", "\n", " \n", " imagerad = np.zeros((fullheight-imgheight, fullwidth))\n", " imagever = np.zeros((fullheight-imgheight, fullwidth))\n", " imagerad = np.insert(imagerad, imgheighthalf, ogimagerad, axis=0)\n", " imagever = np.insert(imagever, imgheighthalf, ogimagever, axis=0)\n", " \n", " #imagever = np.flip(imagever)\n", " #imagerad = np.flip(imagerad)\n", "\n", " imagerad = imagerad[rowrad:rowrad+1,leftstoprad:rightstoprad] #taking signal from only one row of camera detectors\n", " imagever = imagever[rowver:rowver+1,leftstopver:rightstopver]\n", " imagever = np.squeeze(imagever,axis=0)\n", " imagerad = np.squeeze(imagerad,axis=0)\n", " \n", " \n", " sig = np.concatenate((imagever, imagerad), axis=0)\n", " \n", " return sig" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Function where the tomographic inversion is performed:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "tags": [] }, "outputs": [], "source": [ "def datasolve(framenumber: int, sig, grid, magflux, mask, fixed:bool, alpha=[0.7,0.7,0.7]):\n", " \"\"\" Tomographic reconstruction using MFR of single frame data, which saves result\n", "\n", " Args:\n", " framenumber (int): framenumber\n", " sig (_type_): camera signal to be reconstructed, most likely from datafromimage()\n", " grid (_type_): reconstruction grid\n", " magflux (_type_): magnetic flux surfaces\n", " mask (_type_): mask for the reconstruction grid, reconstruction only within limiter right now \n", " fixed (bool): if the function should use the fixed parameter set True (could speed up the reconstruction)\n", "\n", " Returns:\n", " _type_: np.ndarray of reconstructed plane\n", " \"\"\" \n", " \n", " data = sig.reshape(1, -1) # data should have shape (#timeslices, #channels/pixels)\n", " \n", " errors = .02*data + 10 #error estimation. This works, but should be improved and studied further. Has very large impact on results\n", "\n", " # dmats = compute_iso_dmats(grid)\n", " dmats = compute_aniso_dmats(grid, magflux=magflux, mask=mask) #derivative matrix with mask\n", " gmat_sel = gmat[:, bdm.flatten()] #geometric matrix with mask\n", "\n", " aniso = 2 #parameter dictating anisotropy of smoothing perp/parallel to mag flux surfaces\n", "\n", " if fixed == True:\n", " \n", " #Solver that uses a fixed regularization parameter and is therefore faster (about 10 times). \n", " \n", " solver = Fixt()\n", " \n", " res, chi = solver(data, gmat_sel, dmats, errors, aniso=aniso,parameters = alpha)\n", " else: \n", " #Solvers that use full Minimum Fischer Regularization. Slower but \"better\".\n", " \n", " solver = Mfr() # slowlier version based on scipy.sparse\n", "\n", " res, chi = solver(data, gmat_sel, dmats, errors, aniso=aniso)\n", " #print('last reg parameter logalpha = {:.2f}'.format(chi[-1]['logalpha'][-1]))\n", "\n", "\n", "\n", " #reshaping result to original grid shape\n", " res2 = np.zeros((1, grid.shape[0]*grid.shape[1]))\n", " res2[0, bdm.flatten()] = res\n", " res2 = res2.reshape(1, *grid.shape)\n", " np.save(result_folder / 'data' / str(\"res_\"+ str(framenumber)), res2, allow_pickle=True, fix_imports=True)\n", " np.save(result_folder / 'stats' / str(\"stats_\"+ str(framenumber)), chi, allow_pickle=True, fix_imports=True)\n", " return res2, chi\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Main part of the code:**\n", "Here some parameters are defined, like plasma radius etc. to set boundaries for example" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "tags": [] }, "outputs": [], "source": [ "# Define some \"parameters\" used in tokamak GOLEM\n", "\n", "#Parameters:\n", "plasmaradius=0.085 #Radius of plasma (and of the reconstruction domain), 0.085 for limiter. \n", "padding = 0.015 #padding to work with slightly bigger grid for better visualization\n", "#GOLEM parameters:\n", "chamberradius = 0.1 #chamber radius\n", "plasmacentre = 0.40 #minor tokamak radius\n", "\n", "#Curves for limiter contures etc.:\n", "t = np.linspace(0,2*np.pi,100) #t is just a parameter for the curves/circles\n", "#Plasma (determined by limiter)\n", "r = plasmacentre + plasmaradius*np.sin(t)\n", "z = plasmaradius*np.cos(t)\n", "#Chamber wall\n", "R = plasmacentre + chamberradius*np.sin(t)\n", "Z = chamberradius*np.cos(t)\n", "\n", "#Grid minimum and maximum locations in poloidal plane of the GOLEM tokamak for better plotting:\n", "gridrmin = plasmacentre - plasmaradius - padding\n", "gridrmax = plasmacentre + plasmaradius + padding\n", "gridzmin = - plasmaradius - padding\n", "gridzmax = plasmaradius + padding\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Load geometry matrix and grid:**\n", "\n", "The geometry matrix describes the geometry of the field of view of the cameras in relation to the reconstruction grid. The geometry matrix element [i,j] describes how much the emissivity in the i-th region contributes to the signal at the j-th detector. Here, this is done using the line of sight approximation in which the [i,j] element is proportional to the length of the line of sight of the j-th detector intersecting the i-th region.\n", "\n", "The geometry matrix is specific to the cameras used and to the grid size. If any of these are changed, a new geometry matrix has to be generated.\n", "\n", "This geometry matrix was created using Tomotok from Calcam camera calibrations. It is specifically for the UX100 color cameras and their 511th pixel row and a 50x50 reconstruction grid. \n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "tags": [] }, "outputs": [], "source": [ "# Loading sparse_gmat (class with gmat and grid) and extracting data\n", "gmat_load=load_sparse_gmat('./gmat/gmat_40x40') #loading data\n", "gmat=gmat_load[0] # Defining geometry matrix gmat\n", "grid=gmat_load[1] # Defining grid" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A graph showing the cameras' field of view using the sum of geometry matrix elements. " ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "if True: #set True if you want to plot the sum of geometry matrix elements\n", " plt.rcParams['font.size'] = '15'\n", "\n", " f, a = plt.subplots(figsize=(5,5),dpi=100)\n", " # img = a.imshow(res.reshape(grid.shape), origin='lower', extent=grid.extent) # nodes must be squares\n", " img = a.pcolorfast(grid.r_border, grid.z_border, gmat.toarray().sum(0).reshape(grid.shape))\n", " plt.plot(r,z, 'w', lw=1)\n", " plt.plot(R,Z, 'w', lw=1)\n", " a.set_aspect(1)\n", " a.set_xlabel('R [m]')\n", " a.set_ylabel('z [m]')\n", "\n", " plt.title('Geometry matrix')\n", "\n", " plt.xticks([gridrmin,gridrmax,0.4,0.45,0.35])\n", " plt.yticks([gridzmin,gridzmax,0.,0.05,-0.05])\n", " #plt.xticks(rotation = 90)\n", "\n", " cbar = f.colorbar(img, ax=a, fraction=0.0452, pad=0.05)\n", " cbar.ax.set_ylabel('[-]')\n", "\n", " imagename='geometric_matrix.png'\n", " plt.savefig(imagename,bbox_inches=\"tight\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Create mask:**\n", "\n", "The mask is created to limit the reconstruction domain to only the inside of the tokamak chamber. " ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "tags": [] }, "outputs": [], "source": [ "# Calling mask function for defined grid\n", "bdm=create_mask(grid, limiter_mask=False, plasmaradius=plasmaradius)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "tags": [] }, "outputs": [], "source": [ "if False: #set True if you want to plot the mask\n", " plt.figure()\n", " plt.imshow(bdm)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Generating Psi:**\n", "\n", "The magnetic surfaces are used for anisotropical smoothing of the results. \n", "\n", "Currently, the Solovyev solution of the Grad-Shafranov equation is used." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "tags": [] }, "outputs": [], "source": [ "#Psi generation\n", "nr = grid.nr\n", "nz = grid.nz\n", "span = plasmaradius+padding\n", "offsetx = 0.01 #offset of centre in x direction \n", "offsety = 0 #offset of centre in y direction \n", "x = np.linspace(-span, span, nr)\n", "y = np.linspace(-span, span, nz)\n", "mx, my = np.meshgrid(x, y)\n", "\n", "#Simplest possible Psi - concentric circles\n", "#ipsi = np.sqrt((mx -offsetx)*( mx-offsetx) + (my-offsety) *(my-offsety))\n", "\n", "#Simplest ~physical Psi - Solovyev solution of G-S equation\n", "R0 = 0.4\n", "a = 0.085\n", "eps = a/R0\n", "tau = 1\n", "sigma = 1\n", "ipsi = ( ((mx)/a) - (eps/2)*(1-((mx)/a)**2))**2 + (1-eps**2/4)*(my/a)**2\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "if True: #set True if you want to plot the \"Psi\" - smoothing of the result\n", " plt.rcParams['font.size'] = '15'\n", " f, a = plt.subplots(figsize=(5,5),dpi=100)\n", " # img = a.imshow(res.reshape(grid.shape), origin='lower', extent=grid.extent) # nodes must be squares\n", " img = a.pcolorfast(grid.r_border, grid.z_border, ipsi)\n", " plt.plot(r,z, 'w', lw=1)\n", " plt.plot(R,Z, 'k', lw=1)\n", "\n", " a.set_aspect(1)\n", " a.set_xlabel('R [m]')\n", " a.set_ylabel('z [m]')\n", "\n", " plt.title('')\n", "\n", " plt.xticks([gridrmin,gridrmax,0.4,0.45,0.35])\n", " plt.yticks([gridzmin,gridzmax,0.,0.05,-0.05])\n", " #plt.xticks(rotation = 90)\n", "\n", " cbar = f.colorbar(img, ax=a, fraction=0.0452, pad=0.05)\n", " cbar.ax.set_ylabel('Psi [-]')\n", "\n", " imagename='mag_flux.png'\n", " #plt.savefig(imagename,bbox_inches=\"tight\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Set the range of frames you want to compute:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "#Tomographic reconstructions of all frames selected\n", "plasma_start=float(requests.get(f'http://golem.fjfi.cvut.cz/shots/{shot_no}/Diagnostics/PlasmaDetection/Results/t_plasma_start').text)\n", "plasma_end=float(requests.get(f'http://golem.fjfi.cvut.cz/shots/{shot_no}/Diagnostics/PlasmaDetection/Results/t_plasma_end').text)\n", "\n", "minrange = int(plasma_start*FPMS)\n", "maxrange = int(plasma_end*FPMS)+1\n", "\n", "imagesfromvideo(minrange,maxrange)\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "tags": [] }, "outputs": [], "source": [ "if False: #set True if you want to test and see the image data\n", " #Frame numbers to reconstruct\n", " frame = 278 #starting frame number\n", " data = datafromimage(frame,0)\n", " plt.xlabel('Detector number')\n", " plt.ylabel('Signal')\n", " plt.plot(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Compute and immediately plot all tomography results:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "last chi^2 = 0.3120, time: 11.66 s\n", "last chi^2 = 0.4422, time: 0.87 s\n", "last chi^2 = 0.2423, time: 11.22 s\n", "last chi^2 = 0.2814, time: 0.83 s\n", "last chi^2 = 0.2608, time: 11.09 s\n" ] } ], "source": [ "alpha = (0,0,0)\n", "\n", "for i in range(minrange,maxrange):\n", " \n", " data = datafromimage(i,0)\n", " \n", " if i == minrange:\n", " res, stats = datasolve(i, data, grid, ipsi, bdm,fixed=False)\n", " logalpha = stats[0]['logalpha']\n", " alpha = (10**logalpha[0], 10**logalpha[1], 10**logalpha[2])\n", " chi = stats[0]['chi'][-1]\n", " else:\n", " res, stats = datasolve(i, data, grid, ipsi, bdm, fixed=True, alpha = alpha)\n", " \n", " chi = stats[0]['chi'][-1]\n", " if abs(chi - 1) > 0.2:\n", " res, stats = datasolve(i, data, grid, ipsi, bdm,fixed=False)\n", " logalpha = stats[0]['logalpha']\n", " alpha = (10**logalpha[0], 10**logalpha[1], 10**logalpha[2])\n", " chi = stats[0]['chi'][-1]\n", "\n", " \n", " plt.figure()\n", " f, a = plt.subplots(figsize=(5,5),dpi=100)\n", " img = a.pcolorfast(grid.r_border, grid.z_border, np.load(result_folder / 'data' / str(\"res_\"+ str(i)+ \".npy\"), mmap_mode=None, allow_pickle=False, fix_imports=True)[0], snap=True)\n", " plt.plot(r,z, 'w', lw=2)\n", " plt.plot(R,Z, 'k', lw=2)\n", " a.set_aspect(1)\n", " a.set_xlabel('R [m]')\n", " a.set_ylabel('z [m]')\n", " \n", " time = (i)/FPMS\n", "\n", " plt.title('$t_d$ = '+\"{:.3f}\".format(time)+' ms')\n", "\n", " plt.xticks([gridrmin,gridrmax,0.4,0.45,0.35])\n", " plt.yticks([gridzmin,gridzmax,0.,0.05,-0.05])\n", " #plt.xticks(rotation = 90)\n", "\n", " cbar = f.colorbar(img, ax=a, fraction=0.0452, pad=0.05)\n", " cbar.ax.set_ylabel('[-]')\n", "\n", " imagename= result_folder / 'graphs' / str(\"res_\"+ str(i)+ \".png\")\n", " plt.savefig(imagename,bbox_inches=\"tight\",transparent=True)\n", " plt.close('all') \n", " #Magflux based on centre of gravity of previous frame, should be improved\n", " offsetx = np.sum(res * mx)/np.sum(res)\n", " offsety = np.sum(res * my)/np.sum(res)\n", " ipsi = np.sqrt((mx -offsetx)*( mx-offsetx) + (my-offsety) *(my-offsety))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replot all results with the same color scale:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "tags": [] }, "outputs": [], "source": [ "#Plot all reconstructions\n", "\n", "#Finding maximum in all results_iso - to have a stationary colorbar\n", "maxres= 0\n", "for i in range(minrange,maxrange):\n", " res2 = np.load(result_folder / 'data' / str(\"res_\"+ str(i)+ \".npy\"), mmap_mode=None, allow_pickle=True, fix_imports=True)\n", " maxres = max(maxres, np.max(res2))\n", " \n", "plt.rcParams['font.size'] = '15'\n", "\n", "for i in range(minrange,maxrange):\n", " f, a = plt.subplots(figsize=(5,5),dpi=100)\n", " img = a.pcolorfast(grid.r_border, grid.z_border, np.load(result_folder / 'data' / str(\"res_\"+ str(i)+ \".npy\"), mmap_mode=None, allow_pickle=True, fix_imports=True)[0], vmax=0.5*maxres)\n", " plt.plot(r,z, 'w', lw=1)\n", " plt.plot(R,Z, 'k', lw=1)\n", " a.set_aspect(1)\n", " a.set_xlabel('R [m]')\n", " a.set_ylabel('z [m]')\n", " \n", " time = (i)/FPMS\n", "\n", " plt.title('$t_d$ = '+\"{:.3f}\".format(time)+' ms')\n", "\n", " plt.xticks([gridrmin,gridrmax,0.4,0.45,0.35])\n", " plt.yticks([gridzmin,gridzmax,0.,0.05,-0.05])\n", " #plt.xticks(rotation = 90)\n", "\n", " cbar = f.colorbar(img, ax=a, fraction=0.0452, pad=0.05)\n", " cbar.ax.set_ylabel('[-]')\n", "\n", " imagename=result_folder / 'graphs' / str(\"res_\"+ str(i)+ \".png\")\n", " plt.savefig(imagename,bbox_inches=\"tight\",transparent=True)\n", " plt.close('all')\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Combine all graphs into an animation:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "\n", "img_array = []\n", "\n", "#create iconfig for homepage\n", "i = int(0.5*(maxrange-minrange)+minrange)\n", "img = cv2.imread(str(result_folder / 'graphs' / str(\"res_\"+ str(i)+ \".png\")))\n", "cv2.imwrite('tomo_iconfig.png', img) \n", "cv2.imwrite('tomo_ScreenShotAll.png', img) \n", "\n", "for i in range(minrange,maxrange):\n", " img = cv2.imread(str(result_folder / 'graphs' / str(\"res_\"+ str(i)+ \".png\")))\n", " img_array.append(img)\n", "\n", "size = (np.shape(img)[1],np.shape(img)[0])\n", "\n", "out = cv2.VideoWriter('TomographyResult.avi',cv2.VideoWriter_fourcc(*'DIVX'), 10, size)\n", "\n", "for i in range(len(img_array)):\n", " out.write(img_array[i])\n", "out.release()" ] } ], "metadata": { "interpreter": { "hash": "823b433449232ffa024257f9a4d323559a5ef8fa1cde7207ec0907d532cc106a" }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.7.3" } }, "nbformat": 4, "nbformat_minor": 4 }