diff --git a/p3_1_octavekernel.ipynb b/p3_1_octavekernel.ipynb new file mode 100644 index 0000000..ac9c2eb --- /dev/null +++ b/p3_1_octavekernel.ipynb @@ -0,0 +1,676 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Вернемся к Matlab/Octave (Занятие 3_1 в Jupyter)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "close all\n", + "clear all" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "% octave specific function\n", + "pkg load netcdf\n", + "pkg load io\n", + "pkg load statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "fname4='/home/mizyuk/DataW2/AO_MexicanGulf_by_Dop5/SST_Reinolds_7D_AO_MexicanGulf_all_auto.mat.nc'; % имя файла" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ans =\n", + "\n", + " scalar structure containing the fields:\n", + "\n", + " Filename = /home/mizyuk/DataW2/AO_MexicanGulf_by_Dop5/SST_Reinolds_7D_AO_MexicanGulf_all_auto.mat.nc\n", + " Name = /\n", + " Dimensions =\n", + "\n", + " 1x3 struct array containing the fields:\n", + "\n", + " Name\n", + " Length\n", + " Unlimited\n", + "\n", + " Variables =\n", + "\n", + " 1x4 struct array containing the fields:\n", + "\n", + " Name\n", + " Dimensions\n", + " Size\n", + " Datatype\n", + " Attributes\n", + " ChunkSize\n", + " FillValue\n", + " DeflateLevel\n", + " Shuffle\n", + " Checksum\n", + "\n", + " Attributes =\n", + "\n", + " 1x5 struct array containing the fields:\n", + "\n", + " Name\n", + " Value\n", + "\n", + " Groups = [](0x0)\n", + " Format = netcdf4\n", + "\n" + ] + } + ], + "source": [ + "ncinfo(fname4) % инфо к nc файлу" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "загружаем перменные" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "x=ncread(fname4,'lon'); % долгота\n", + "y=ncread(fname4,'lat'); % широта\n", + "d=ncread(fname4,'time'); % дата\n", + "aa=ncread(fname4,'aa'); % массив температуры" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ans =\n", + "\n", + " 56 72 476\n", + "\n" + ] + } + ], + "source": [ + "size(aa)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "aa(aa==0)=nan; % 0all zeros to Nan (Not A Number)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ans = 1\n" + ] + } + ], + "source": [ + "picdir='Results/SST_Reinolds_7D/'; % название директории\n", + "mkdir(picdir) % создаем директорию" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "%% среднее за выбранный год\n", + "dv=datevec(d); % дата переводится в вектор (год, месяц, число, день, час, минута)\n", + "year=dv(:,1); % год\n", + "\n", + "yu1=2013; % будем строить за 2013\n", + "\n", + "inye=find(year==yu1); % ищем индекс даты год которой равен 2013\n", + "aa1=aa(:,:,inye); % выбираем только эти индексы\n", + "\n", + "aam=nanmean(aa1,3); % среднее по времени (3-ая размерность)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "aam(aam<1)=nan;" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'print' is a function from the file /usr/share/octave/4.2.2/m/plot/util/print.m\r\n", + "\r\n", + " -- print ()\r\n", + " -- print (OPTIONS)\r\n", + " -- print (FILENAME, OPTIONS)\r\n", + " -- print (H, FILENAME, OPTIONS)\r\n", + " Print a plot, or save it to a file.\r\n", + "\r\n", + " Both output formatted for printing (PDF and PostScript), and many\r\n", + " bitmapped and vector image formats are supported.\r\n", + "\r\n", + " FILENAME defines the name of the output file. If the filename has\r\n", + " no suffix, one is inferred from the specified device and appended\r\n", + " to the filename. If no filename is specified, the output is sent\r\n", + " to the printer.\r\n", + "\r\n", + " H specifies the handle of the figure to print. If no handle is\r\n", + " specified the current figure is used.\r\n", + "\r\n", + " For output to a printer, PostScript file, or PDF file, the paper\r\n", + " size is specified by the figure's 'papersize' property. The\r\n", + " location and size of the image on the page are specified by the\r\n", + " figure's 'paperposition' property. The orientation of the page is\r\n", + " specified by the figure's 'paperorientation' property.\r\n", + "\r\n", + " The width and height of images are specified by the figure's\r\n", + " 'paperposition(3:4)' property values.\r\n", + "\r\n", + " The 'print' command supports many OPTIONS:\r\n", + "\r\n", + " '-fH'\r\n", + " Specify the handle, H, of the figure to be printed. The\r\n", + " default is the current figure.\r\n", + "\r\n", + " '-PPRINTER'\r\n", + " Set the PRINTER name to which the plot is sent if no FILENAME\r\n", + " is specified.\r\n", + "\r\n", + " '-GGHOSTSCRIPT_COMMAND'\r\n", + " Specify the command for calling Ghostscript. For Unix and\r\n", + " Windows the defaults are \"gs\" and \"gswin32c\", respectively.\r\n", + "\r\n", + " '-color'\r\n", + " '-mono'\r\n", + " Color or monochrome output.\r\n", + "\r\n", + " '-solid'\r\n", + " '-dashed'\r\n", + " Force all lines to be solid or dashed, respectively.\r\n", + "\r\n", + " '-portrait'\r\n", + " '-landscape'\r\n", + " Specify the orientation of the plot for printed output. For\r\n", + " non-printed output the aspect ratio of the output corresponds\r\n", + " to the plot area defined by the \"paperposition\" property in\r\n", + " the orientation specified. This option is equivalent to\r\n", + " changing the figure's \"paperorientation\" property.\r\n", + "\r\n", + " '-TextAlphaBits=N'\r\n", + " '-GraphicsAlphaBits=N'\r\n", + " Octave is able to produce output for various printers,\r\n", + " bitmaps, and vector formats by using Ghostscript. For bitmap\r\n", + " and printer output anti-aliasing is applied using\r\n", + " Ghostscript's TextAlphaBits and GraphicsAlphaBits options.\r\n", + " The default number of bits are 4 and 1 respectively. Allowed\r\n", + " values for N are 1, 2, or 4.\r\n", + "\r\n", + " '-dDEVICE'\r\n", + " The available output format is specified by the option DEVICE,\r\n", + " and is one of:\r\n", + "\r\n", + " 'ps'\r\n", + " 'ps2'\r\n", + " 'psc'\r\n", + " 'psc2'\r\n", + " PostScript (level 1 and 2, mono and color). The\r\n", + " OpenGL-based toolkits always generate PostScript level\r\n", + " 3.0.\r\n", + "\r\n", + " 'eps'\r\n", + " 'eps2'\r\n", + " 'epsc'\r\n", + " 'epsc2'\r\n", + " Encapsulated PostScript (level 1 and 2, mono and color).\r\n", + " The OpenGL-based toolkits always generate PostScript\r\n", + " level 3.0.\r\n", + "\r\n", + " 'pslatex'\r\n", + " 'epslatex'\r\n", + " 'pdflatex'\r\n", + " 'pslatexstandalone'\r\n", + " 'epslatexstandalone'\r\n", + " 'pdflatexstandalone'\r\n", + " Generate a LaTeX file 'FILENAME.tex' for the text\r\n", + " portions of a plot and a file 'FILENAME.(ps|eps|pdf)' for\r\n", + " the remaining graphics. The graphics file suffix\r\n", + " .ps|eps|pdf is determined by the specified device type.\r\n", + " The LaTeX file produced by the 'standalone' option can be\r\n", + " processed directly by LaTeX. The file generated without\r\n", + " the 'standalone' option is intended to be included from\r\n", + " another LaTeX document. In either case, the LaTeX file\r\n", + " contains an '\\includegraphics' command so that the\r\n", + " generated graphics file is automatically included when\r\n", + " the LaTeX file is processed. The text that is written to\r\n", + " the LaTeX file contains the strings *exactly* as they\r\n", + " were specified in the plot. If any special characters of\r\n", + " the TeX mode interpreter were used, the file must be\r\n", + " edited before LaTeX processing. Specifically, the\r\n", + " special characters must be enclosed with dollar signs ('$\r\n", + " ... $'), and other characters that are recognized by\r\n", + " LaTeX may also need editing (.e.g., braces). The\r\n", + " 'pdflatex' device, and any of the 'standalone' formats,\r\n", + " are not available with the Gnuplot toolkit.\r\n", + "\r\n", + " 'epscairo'\r\n", + " 'pdfcairo'\r\n", + " 'epscairolatex'\r\n", + " 'pdfcairolatex'\r\n", + " 'epscairolatexstandalone'\r\n", + " 'pdfcairolatexstandalone'\r\n", + " Generate Cairo based output when using the Gnuplot\r\n", + " graphics toolkit. The 'epscairo' and 'pdfcairo' devices\r\n", + " are synonymous with the 'epsc' device. The LaTeX\r\n", + " variants generate a LaTeX file, 'FILENAME.tex', for the\r\n", + " text portions of a plot, and an image file,\r\n", + " 'FILENAME.(eps|pdf)', for the graph portion of the plot.\r\n", + " The 'standalone' variants behave as described for\r\n", + " 'epslatexstandalone' above.\r\n", + "\r\n", + " 'ill'\r\n", + " 'aifm'\r\n", + " Adobe Illustrator (Obsolete for Gnuplot versions > 4.2)\r\n", + "\r\n", + " 'canvas'\r\n", + " Javascript-based drawing on HTML5 canvas viewable in a\r\n", + " web browser (only available for the Gnuplot graphics\r\n", + " toolkit).\r\n", + "\r\n", + " 'cdr'\r\n", + " 'corel'\r\n", + " CorelDraw\r\n", + "\r\n", + " 'dxf'\r\n", + " AutoCAD\r\n", + "\r\n", + " 'emf'\r\n", + " 'meta'\r\n", + " Microsoft Enhanced Metafile\r\n", + "\r\n", + " 'fig'\r\n", + " XFig. For the Gnuplot graphics toolkit, the additional\r\n", + " options '-textspecial' or '-textnormal' can be used to\r\n", + " control whether the special flag should be set for the\r\n", + " text in the figure. (default is '-textnormal')\r\n", + "\r\n", + " 'gif'\r\n", + " GIF image (only available for the Gnuplot graphics\r\n", + " toolkit)\r\n", + "\r\n", + " 'hpgl'\r\n", + " HP plotter language\r\n", + "\r\n", + " 'jpg'\r\n", + " 'jpeg'\r\n", + " JPEG image\r\n", + "\r\n", + " 'latex'\r\n", + " LaTeX picture environment (only available for the Gnuplot\r\n", + " graphics toolkit).\r\n", + "\r\n", + " 'mf'\r\n", + " Metafont\r\n", + "\r\n", + " 'png'\r\n", + " Portable network graphics\r\n", + "\r\n", + " 'pbm'\r\n", + " PBMplus\r\n", + "\r\n", + " 'pdf'\r\n", + " Portable document format\r\n", + "\r\n", + " 'svg'\r\n", + " Scalable vector graphics\r\n", + "\r\n", + " 'tikz'\r\n", + " 'tikzstandalone'\r\n", + " Generate a LaTeX file using PGF/TikZ format. The OpenGL-based\r\n", + " toolkits create a PGF file while Gnuplot creates a TikZ file.\r\n", + " The 'tikzstandalone' device produces a LaTeX document which\r\n", + " includes the TikZ file ('tikzstandalone' and is only available\r\n", + " for the Gnuplot graphics toolkit).\r\n", + "\r\n", + " If the device is omitted, it is inferred from the file\r\n", + " extension, or if there is no filename it is sent to the\r\n", + " printer as PostScript.\r\n", + "\r\n", + " '-dGHOSTSCRIPT_DEVICE'\r\n", + " Additional devices are supported by Ghostscript. Some\r\n", + " examples are;\r\n", + "\r\n", + " 'pdfwrite'\r\n", + " Produces pdf output from eps\r\n", + "\r\n", + " 'ljet2p'\r\n", + " HP LaserJet IIP\r\n", + "\r\n", + " 'pcx24b'\r\n", + " 24-bit color PCX file format\r\n", + "\r\n", + " 'ppm'\r\n", + " Portable Pixel Map file format\r\n", + "\r\n", + " For a complete list, type 'system (\"gs -h\")' to see what\r\n", + " formats and devices are available.\r\n", + "\r\n", + " When Ghostscript output is sent to a printer the size is\r\n", + " determined by the figure's \"papersize\" property. When the\r\n", + " output is sent to a file the size is determined by the plot\r\n", + " box defined by the figure's \"paperposition\" property.\r\n", + "\r\n", + " '-append'\r\n", + " Append PostScript or PDF output to a pre-existing file of the\r\n", + " same type.\r\n", + "\r\n", + " '-rNUM'\r\n", + " Resolution of bitmaps in pixels per inch. For both metafiles\r\n", + " and SVG the default is the screen resolution; for other\r\n", + " formats it is 150 dpi. To specify screen resolution, use\r\n", + " \"-r0\".\r\n", + "\r\n", + " '-loose'\r\n", + " '-tight'\r\n", + " Force a tight or loose bounding box for eps files. The\r\n", + " default is loose.\r\n", + "\r\n", + " '-PREVIEW'\r\n", + " Add a preview to eps files. Supported formats are:\r\n", + "\r\n", + " '-interchange'\r\n", + " Provide an interchange preview.\r\n", + "\r\n", + " '-metafile'\r\n", + " Provide a metafile preview.\r\n", + "\r\n", + " '-pict'\r\n", + " Provide pict preview.\r\n", + "\r\n", + " '-tiff'\r\n", + " Provide a tiff preview.\r\n", + "\r\n", + " '-SXSIZE,YSIZE'\r\n", + " Plot size in pixels for EMF, GIF, JPEG, PBM, PNG, and SVG.\r\n", + " For PS, EPS, PDF, and other vector formats the plot size is in\r\n", + " points. This option is equivalent to changing the size of the\r\n", + " plot box associated with the \"paperposition\" property. When\r\n", + " using the command form of the print function you must quote\r\n", + " the XSIZE,YSIZE option. For example, by writing \"-S640,480\".\r\n", + "\r\n", + " '-FFONTNAME'\r\n", + " '-FFONTNAME:SIZE'\r\n", + " '-F:SIZE'\r\n", + " Use FONTNAME and/or FONTSIZE for all text. FONTNAME is\r\n", + " ignored for some devices: dxf, fig, hpgl, etc.\r\n", + "\r\n", + " The filename and options can be given in any order.\r\n", + "\r\n", + " Example: Print to a file using the pdf device.\r\n", + "\r\n", + " figure (1);\r\n", + " clf ();\r\n", + " surf (peaks);\r\n", + " print figure1.pdf\r\n", + "\r\n", + " Example: Print to a file using jpg device.\r\n", + "\r\n", + " clf ();\r\n", + " surf (peaks);\r\n", + " print -djpg figure2.jpg\r\n", + "\r\n", + " Example: Print to printer named PS_printer using ps format.\r\n", + "\r\n", + " clf ();\r\n", + " surf (peaks);\r\n", + " print -dpswrite -PPS_printer\r\n", + "\r\n", + " See also: saveas, hgsave, orient, figure.\r\n", + "\r\n", + "Additional help for built-in functions and operators is\r\n", + "available in the online version of the manual. Use the command\r\n", + "'doc ' to search the manual index.\r\n", + "\r\n", + "Help and information about Octave is also available on the WWW\r\n", + "at http://www.octave.org and via the help@octave.org\r\n", + "mailing list.\r\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print?" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "c = -7.9522\n", + "warning: print.m: fig2dev binary is not available.\n", + "Some output formats are not available.\n", + "warning: called from\n", + " __print_parse_opts__ at line 388 column 9\n", + " print at line 316 column 8\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "% рисуем\n", + "figure\n", + "axes('fontsize',18)\n", + "% contourf(x,y,aam,30) % 1 контур\n", + "imagesc(x,y,aam) % 2 рисунок\n", + "% imagescn(x,y,aam) % 3 без нанов\n", + "axis xy\n", + "c=colorbar('fontsize',28)\n", + "xlabel('Longitude')\n", + "%ylabel\n", + "title('Average SST in 2013')\n", + "grid on\n", + "colormap(jet)\n", + "c1=prctile(aam(:),3); % автоподбор по шкале\n", + "c2=prctile(aam(:),97); % автоподбор по шкале\n", + "caxis([c1 c2])% ограничение шкалы\n", + "savname='SST_Reinolds_7D_year2013.jpeg'; % имя рисунка\n", + "print(gcf,'-r150','-djpeg',[picdir savname]) % сохраняем рисунок" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'shading' is a function from the file /usr/share/octave/4.2.2/m/plot/appearance/shading.m\r\n", + "\r\n", + " -- shading (TYPE)\r\n", + " -- shading (HAX, TYPE)\r\n", + " Set the shading of patch or surface graphic objects.\r\n", + "\r\n", + " Valid arguments for TYPE are\r\n", + "\r\n", + " \"flat\"\r\n", + " Single colored patches with invisible edges.\r\n", + "\r\n", + " \"faceted\"\r\n", + " Single colored patches with black edges.\r\n", + "\r\n", + " \"interp\"\r\n", + " Colors between patch vertices are interpolated and the patch\r\n", + " edges are invisible.\r\n", + "\r\n", + " If the first argument HAX is an axes handle, then plot into this\r\n", + " axes, rather than the current axes returned by 'gca'.\r\n", + "\r\n", + " See also: fill, mesh, patch, pcolor, surf, surface, hidden,\r\n", + " lighting.\r\n", + "\r\n", + "Additional help for built-in functions and operators is\r\n", + "available in the online version of the manual. Use the command\r\n", + "'doc ' to search the manual index.\r\n", + "\r\n", + "Help and information about Octave is also available on the WWW\r\n", + "at http://www.octave.org and via the help@octave.org\r\n", + "mailing list.\r\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "shading?" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "c = -7.1088\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "% рисуем\n", + "figure\n", + "axes('fontsize',18)\n", + "% contourf(x,y,aam,30) % 1 контур\n", + "% imagesc(x,y,aam) % 2 рисунок\n", + "pcolor(x,y,aam) % 2 рисунок\n", + "shading('flat')\n", + "% imagescn(x,y,aam) % 3 без нанов\n", + "axis xy\n", + "c=colorbar('fontsize',28)\n", + "xlabel('Longitude')\n", + "%ylabel\n", + "title('Average SST in 2013')\n", + "grid on\n", + "colormap(jet)\n", + "c1=prctile(aam(:),3); % автоподбор по шкале\n", + "c2=prctile(aam(:),97); % автоподбор по шкале\n", + "caxis([c1 c2])% ограничение шкалы\n", + "savname='SST_Reinolds_7D_year2013_pcolor.jpeg'; % имя рисунка\n", + "% print(gcf,'-r150','-djpeg',[picdir savname]) % сохраняем рисунок" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Octave", + "language": "octave", + "name": "octave" + }, + "language_info": { + "file_extension": ".m", + "help_links": [ + { + "text": "GNU Octave", + "url": "https://www.gnu.org/software/octave/support.html" + }, + { + "text": "Octave Kernel", + "url": "https://github.com/Calysto/octave_kernel" + }, + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "octave", + "version": "4.2.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/p3_1_pykernel.ipynb b/p3_1_pykernel.ipynb new file mode 100644 index 0000000..4214439 --- /dev/null +++ b/p3_1_pykernel.ipynb @@ -0,0 +1,1181 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# То же самое в Python (Pylab) + нюансы netcdf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "pkg load netcdf" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'ncread' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mncread\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'ncread' is not defined" + ] + } + ], + "source": [ + "ncread" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Чтобы прочитать netcdf в python есть несколько вариантов. В данном уроке рассмотрим низкоуровневую библиотеку netCDF4\n", + "\n", + "**Задание**: установите пакет netCDF4 в свое окружение" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from netCDF4 import Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "fname4 = '/home/mizyuk/DataW2/AO_MexicanGulf_by_Dop5/SST_Reinolds_7D_AO_MexicanGulf_all_auto.mat.nc' # имя файла" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "f = Dataset(fname4) # инфо к nc файлу" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "загружаем перменные" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "root group (NETCDF4 data model, file format HDF5):\n", + " creation_time: 19-Nov-2018 16:55:09\n", + " product: SST_Reinolds_7D\n", + " creator: MHI, Remote Sensing Department, Kubryakov A.A.\n", + " source: Reinolds\n", + " grid_mapping: crs\n", + " dimensions(sizes): lat(56), lon(72), date(476)\n", + " variables(dimensions): float32 \u001b[4maa\u001b[0m(date,lon,lat), float32 \u001b[4mlon\u001b[0m(lon), float32 \u001b[4mlat\u001b[0m(lat), float32 \u001b[4mtime\u001b[0m(date)\n", + " groups: " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "x = f.variables['lon'] # долгота\n", + "y = f.variables['lat'] # широта\n", + "d = f.variables['time'] # дата\n", + "aa = f.variables['aa'] # массив температуры" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "netCDF4._netCDF4.Variable" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "класс переменной netcdf" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "float32 lon(lon)\n", + " _FillValue: nan\n", + " longname: Longitude\n", + "unlimited dimensions: \n", + "current shape = (72,)\n", + "filling on" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "класс array" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В данно случае чтобы превратить переменную netcdf в array сделаем следующее" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "masked_array(data=[-97.875, -97.625, -97.375, -97.125, -96.875, -96.625,\n", + " -96.375, -96.125, -95.875, -95.625, -95.375, -95.125,\n", + " -94.875, -94.625, -94.375, -94.125, -93.875, -93.625,\n", + " -93.375, -93.125, -92.875, -92.625, -92.375, -92.125,\n", + " -91.875, -91.625, -91.375, -91.125, -90.875, -90.625,\n", + " -90.375, -90.125, -89.875, -89.625, -89.375, -89.125,\n", + " -88.875, -88.625, -88.375, -88.125, -87.875, -87.625,\n", + " -87.375, -87.125, -86.875, -86.625, -86.375, -86.125,\n", + " -85.875, -85.625, -85.375, -85.125, -84.875, -84.625,\n", + " -84.375, -84.125, -83.875, -83.625, -83.375, -83.125,\n", + " -82.875, -82.625, -82.375, -82.125, -81.875, -81.625,\n", + " -81.375, -81.125, -80.875, -80.625, -80.375, -80.125],\n", + " mask=False,\n", + " fill_value=1e+20,\n", + " dtype=float32)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x[:]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "72" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "size(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1919232" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "size(aa)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Функция shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(476, 72, 56)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "shape(aa)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Некоторые функции для классов реализованны как свойства. Свойства классов вызываются через \".\" после имени переменной" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(476, 72, 56)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aa.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "мы получили такую размерность массива. Проверим чему они соответсвтуют." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "root group (NETCDF4 data model, file format HDF5):\n", + " creation_time: 19-Nov-2018 16:55:09\n", + " product: SST_Reinolds_7D\n", + " creator: MHI, Remote Sensing Department, Kubryakov A.A.\n", + " source: Reinolds\n", + " grid_mapping: crs\n", + " dimensions(sizes): lat(56), lon(72), date(476)\n", + " variables(dimensions): float32 \u001b[4maa\u001b[0m(date,lon,lat), float32 \u001b[4mlon\u001b[0m(lon), float32 \u001b[4mlat\u001b[0m(lat), float32 \u001b[4mtime\u001b[0m(date)\n", + " groups: " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Примечание №1*: \n", + "мы получили следующее положение размерностей:\n", + "\n", + "**T(время) X(долгота) Y(широта)**\n", + "\n", + "Однако, согласно [cf-конвенций](http://cfconventions.org/cf-conventions/cf-conventions#dimensions)\n", + "их положение предлагается (хоть и не требуется!) таким:\n", + "\n", + "**T(время) [Z(глубина)] Y(широта) X(долгота)**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Проверим это на одном из массивов REMSS" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "f1 = Dataset('/home/mizyuk/DataW2/REMSS/testdatasets/REMSS/la_plata_20060101_20081231.nc')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "root group (NETCDF4 data model, file format HDF5):\n", + " dimensions(sizes): time(1096), lat(250), lon(205)\n", + " variables(dimensions): int64 \u001b[4mtime\u001b[0m(time), int16 \u001b[4manalysed_sst\u001b[0m(time,lat,lon)\n", + " groups: " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f1" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "f1.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Увидим, к чему это приведет позже..." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Математические операции определены только для класса array из пакета numpy" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "aa = aa[:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "в numpy для работы с массивами с пропущенными данными есть специальный подкласс masked_array" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "masked_array(\n", + " data=[[[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [27.780000686645508, 27.780000686645508, 27.790000915527344,\n", + " ..., 16.90999984741211, 15.850000381469727,\n", + " 14.489999771118164],\n", + " [27.8799991607666, 27.8700008392334, 27.850000381469727, ...,\n", + " 19.09000015258789, 17.799999237060547, 15.789999961853027],\n", + " [27.93000030517578, 27.920000076293945, 27.8700008392334, ...,\n", + " 20.84000015258789, 19.510000228881836, 17.639999389648438]],\n", + "\n", + " [[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [27.34000015258789, 27.3799991607666, 27.3799991607666, ...,\n", + " 17.860000610351562, 16.809999465942383, 15.65999984741211],\n", + " [27.31999969482422, 27.34000015258789, 27.3700008392334, ...,\n", + " 19.6299991607666, 18.260000228881836, 16.690000534057617],\n", + " [27.299999237060547, 27.329999923706055, 27.329999923706055,\n", + " ..., 21.010000228881836, 19.700000762939453,\n", + " 18.040000915527344]],\n", + "\n", + " [[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [27.260000228881836, 27.229999542236328, 27.190000534057617,\n", + " ..., 16.360000610351562, 15.279999732971191,\n", + " 14.34000015258789],\n", + " [27.209999084472656, 27.170000076293945, 27.139999389648438,\n", + " ..., 18.219999313354492, 17.079999923706055,\n", + " 15.800000190734863],\n", + " [27.1200008392334, 27.06999969482422, 27.049999237060547, ...,\n", + " 20.040000915527344, 18.790000915527344, 17.6200008392334]],\n", + "\n", + " ...,\n", + "\n", + " [[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [28.459999084472656, 28.549999237060547, 28.65999984741211,\n", + " ..., 18.110000610351562, 17.639999389648438, 16.8700008392334],\n", + " [28.3799991607666, 28.479999542236328, 28.540000915527344, ...,\n", + " 19.790000915527344, 19.09000015258789, 18.09000015258789],\n", + " [28.31999969482422, 28.3700008392334, 28.40999984741211, ...,\n", + " 21.709999084472656, 21.010000228881836, 19.84000015258789]],\n", + "\n", + " [[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [27.8700008392334, 27.709999084472656, 27.610000610351562, ...,\n", + " 19.399999618530273, 18.579999923706055, 17.1299991607666],\n", + " [27.989999771118164, 27.829999923706055, 27.729999542236328,\n", + " ..., 21.329999923706055, 20.25, 18.450000762939453],\n", + " [28.049999237060547, 27.899999618530273, 27.81999969482422,\n", + " ..., 22.959999084472656, 21.959999084472656, 20.25]],\n", + "\n", + " [[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [27.850000381469727, 27.700000762939453, 27.600000381469727,\n", + " ..., 18.969999313354492, 17.8700008392334, 16.280000686645508],\n", + " [27.90999984741211, 27.75, 27.65999984741211, ...,\n", + " 21.219999313354492, 19.969999313354492, 18.059999465942383],\n", + " [27.920000076293945, 27.780000686645508, 27.649999618530273,\n", + " ..., 23.18000030517578, 22.059999465942383,\n", + " 20.139999389648438]]],\n", + " mask=[[[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False]],\n", + "\n", + " [[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False]],\n", + "\n", + " [[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False]],\n", + "\n", + " ...,\n", + "\n", + " [[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False]],\n", + "\n", + " [[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False]],\n", + "\n", + " [[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False]]],\n", + " fill_value=nan,\n", + " dtype=float32)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aa" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "aa(aa==0)=nan; % 0all zeros to Nan (Not A Number)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Воспользуемся функцией pcolor (или image) для визуализации" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pcolormesh(aa[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Примечание №2*: в python если вы итерируете по внешней размерности не обязательно указывать остальные. Это связано с важным свойством, которым мы будем пользоваться позже!\n", + "\n", + "Сейчас, возможно, кто-то заметил, какая проблема у нас возникла." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "picdir = 'Results/SST_Reinolds_7D/' # название директории" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'datevec' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m## среднее за выбранный год\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mdv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdatevec\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# дата переводится в вектор (год, месяц, число, день, час, минута)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'datevec' is not defined" + ] + } + ], + "source": [ + "## среднее за выбранный год\n", + "dv = datevec(d) # дата переводится в вектор (год, месяц, число, день, час, минута)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "функции datevec у нас конежно же нет" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime,timedelta" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "d = d[:]" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext oct2py.ipython" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "%octave_push d" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ans =" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " 2008 1 4 0 0 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " 2008 1 11 0 0 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " 2008 1 18 0 0 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " 2008 1 25 0 0 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " 2008 2 1 0 0 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " 2008 2 8 0 0 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " 2008 2 15 0 0 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " 2008 2 22 0 0 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " 2008 2 29 0 0 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " 2008 3 7 0 0 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%octave\n", + "datevec(d(1:10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Наши даты это количество дней от условного \"Рождества Христова\" (0-го года)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ans =" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " 0 1 1 0 0 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%octave\n", + "datevec(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Замечание №3*: В matlab/octave придумана удобная система работы с датами. **Но**, к сожалению, она применима не везде, потому что ни в григорианском, ни в юлианском календарях нет [0-го года](https://ru.wikipedia.org/wiki/0_год)!" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "year 0 is out of range", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdatetime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: year 0 is out of range" + ] + } + ], + "source": [ + "datetime(0,1,1,0,0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Понятно, что Арсений специально подготовил для нас массивы. Будем выкручиваться." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "dv = [(datetime.fromordinal(d1)-timedelta(days=366)) for d1 in d]" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "dv = array(dv)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "year = array([d.year for d in dv]) # год" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "yu1 = 2013 # будем строить за 2013" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "aa2013 = aa[year==2013] # выбираем только эти индексы" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(53, 72, 56)" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aa2013.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "aam = aa2013.mean(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "Dimensions of C (72, 56) are incompatible with X (72) and/or Y (56); see help(pcolor)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# figure(figsize=(8,6))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mpcolor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0maam\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# 2 рисунок\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/opt/miniconda/envs/satocean/lib/python3.7/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mpcolor\u001b[0;34m(alpha, norm, cmap, vmin, vmax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2759\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2760\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmax\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m\"data\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m}\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2761\u001b[0;31m **kwargs)\n\u001b[0m\u001b[1;32m 2762\u001b[0m \u001b[0msci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m__ret\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2763\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m__ret\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/miniconda/envs/satocean/lib/python3.7/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1808\u001b[0m \u001b[0;34m\"the Matplotlib list!)\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlabel_namer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1809\u001b[0m RuntimeWarning, stacklevel=2)\n\u001b[0;32m-> 1810\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1811\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1812\u001b[0m inner.__doc__ = _add_data_doc(inner.__doc__,\n", + "\u001b[0;32m/opt/miniconda/envs/satocean/lib/python3.7/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mpcolor\u001b[0;34m(self, alpha, norm, cmap, vmin, vmax, *args, **kwargs)\u001b[0m\n\u001b[1;32m 5716\u001b[0m \u001b[0malways\u001b[0m \u001b[0mdiscards\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mlast\u001b[0m \u001b[0mrow\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mcolumn\u001b[0m \u001b[0mof\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mC\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5717\u001b[0m \"\"\"\n\u001b[0;32m-> 5718\u001b[0;31m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mC\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pcolorargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'pcolor'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallmatch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5719\u001b[0m \u001b[0mNy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5720\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/miniconda/envs/satocean/lib/python3.7/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36m_pcolorargs\u001b[0;34m(funcname, allmatch, *args)\u001b[0m\n\u001b[1;32m 5573\u001b[0m raise TypeError('Dimensions of C %s are incompatible with'\n\u001b[1;32m 5574\u001b[0m ' X (%d) and/or Y (%d); see help(%s)' % (\n\u001b[0;32m-> 5575\u001b[0;31m C.shape, Nx, Ny, funcname))\n\u001b[0m\u001b[1;32m 5576\u001b[0m \u001b[0mC\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mC\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mNy\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0mNx\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5577\u001b[0m \u001b[0mC\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msafe_masked_invalid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mC\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: Dimensions of C (72, 56) are incompatible with X (72) and/or Y (56); see help(pcolor)" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# figure(figsize=(8,6))\n", + "pcolor(x,y,aam) # 2 рисунок" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Очевидно, что массив надо транспонировать" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(8,6))\n", + "pcolor(x,y,aam.T) # 2 рисунок" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Mean SST in 2013 year')" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(8,6))\n", + "pcolor(x,y,aam.T)\n", + "grid()\n", + "title('Mean SST in '+str(yu1)+' year')" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(8,6))\n", + "pcolor(x,y,aam.T,cmap='gist_ncar')\n", + "colorbar()\n", + "grid(linestyle='--')\n", + "title('Mean SST in '+str(yu1)+' year')\n", + "savefig('Results/SST_Reinolds_7D/from_python.png',dpi=300,bbox_inches='tight')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "SatOcean", + "language": "python", + "name": "satocean" + }, + "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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}