{ "cells": [ { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import pandas as pd, numpy as np\n", "from scipy import stats" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "stations=pd.read_csv('data/stations.csv').set_index('ID')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "c='ro'\n", "df=pd.read_csv('data/'+c+'_ds.csv') #daily data\n", "# df=pd.read_csv('data/'+c+'_hs.csv') #high_res data\n", "df['time']=pd.to_datetime(df['time'])\n", "df['year']=df['time'].dt.year\n", "df['month']=df['time'].dt.month\n", "df['day']=df['time'].dt.day\n", "df['hour']=df['time'].dt.hour\n", "df=df.set_index('time')\n", "df=df.sort_index()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df.groupby('year').nunique()['ID'].plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "history=df.groupby('ID').nunique()['year'].sort_values(ascending=False)\n", "history=pd.DataFrame(history).join(stations)\n", "history.head()" ] }, { "cell_type": "code", "execution_count": 2601, "metadata": {}, "outputs": [], "source": [ "nepi=pd.read_excel(c+'/idojaras_'+c+'.xlsx')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Setup plot params" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "from matplotlib.collections import PolyCollection\n", "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import matplotlib as mpl\n", "import matplotlib.font_manager as font_manager\n", "path = 'KulimPark-Regular.ttf'\n", "path2 = 'Symbola.ttf'\n", "prop = font_manager.FontProperties(fname=path)\n", "prop2 = font_manager.FontProperties(fname=path2)" ] }, { "cell_type": "code", "execution_count": 2663, "metadata": {}, "outputs": [], "source": [ "color_ax='#E7CFBC'\n", "color_bg='#FFF4EC'\n", "color_obs_right0='#F2B880'\n", "color_obs_left0=color_ax\n", "color_pred_right0='#C98686'\n", "color_pred_left0='#966B9D'\n", "color_pred_talalt0='#59c687'\n", "color_pred_nem_talalt0='#c95498'\n", "font_size=12\n", "s=40\n", "obs_talalt_glyph0='★'\n", "obs_nem_talalt_glyph0='☆'\n", "pred_talalt_glyph0='✔️'\n", "pred_nem_talalt_glyph0='✖️'\n", "title_icon_right={'Temp':'☼','Wind':'►','Hail':'▲','Snow':'▲','Snow Depth':'▲','Rain':'☔️','Visib':'☀️'}\n", "title_icon_left={'Temp':'❄️','Wind':'◄','Hail':'▼','Snow':'▼','Snow Depth':'▼','Rain':'☂️','Visib':'☁️'}\n", "title_icon={'Temp':'♨️','Rain':'☂️','Hail':'❄️','Snow':'⛷️','Snow Depth':'⛄️','Wind':'☘','Cloud':'☁️','Visib':'☀️'}" ] }, { "cell_type": "code", "execution_count": 2664, "metadata": {}, "outputs": [], "source": [ "def get_data(data,th):\n", " a1=pd.DataFrame(data[data<=th])\n", " a1['g']='left'\n", " a2=pd.DataFrame(data[data>th])\n", " a2['g']='right'\n", " a3=pd.concat([a1,a2])\n", " a3['x']='x'\n", " return a1,a2,a3" ] }, { "cell_type": "code", "execution_count": 2790, "metadata": {}, "outputs": [], "source": [ "def violin_plot(data,th,ax,color_left,color_right):\n", " a=0.3\n", " a1,a2,a3=get_data(data,th)\n", " if len(a1)==1: \n", " a11=pd.DataFrame(a1)\n", " a11['x']='x'\n", " a11[a1.columns[0]]=[a1[a1.columns[0]].values[0]*1.1]\n", " a3=pd.concat([a3,a11])\n", " ax.axvline(0,color=color_ax)\n", " if a3.nunique()['g']>1:\n", " sns.violinplot(y=a1.columns[0], x='x',hue='g', data=a3, split=True, ax=ax,\n", " inner=None,linewidth=1, scale=\"count\", saturation=1)\n", "\n", " ax.get_children()[0].set_color(matplotlib.colors.colorConverter.to_rgba(color_left, alpha=a))\n", " ax.get_children()[0].set_edgecolor(color_left)\n", " ax.get_children()[1].set_color(matplotlib.colors.colorConverter.to_rgba(color_right, alpha=a))\n", " ax.get_children()[1].set_edgecolor(color_right)\n", " ax.legend().remove()\n", " else:\n", " if len(a1)>0: \n", " w=a1\n", " c=color_left\n", " else: \n", " w=a2\n", " c=color_right\n", " sns.violinplot(y=w.columns[0], data=w, ax=ax, \n", " inner=None,linewidth=1, scale=\"count\", saturation=1)\n", " ax.set_xlim([-1,0])\n", " ax.get_children()[0].set_color(matplotlib.colors.colorConverter.to_rgba(c, alpha=a))\n", " ax.get_children()[0].set_edgecolor(c)" ] }, { "cell_type": "code", "execution_count": 2792, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "spine_plot(datum,nep['Mondás'].strip(),mondas,nep['Jelentés'].strip(),nep['Kondíció'],nep['Mennyiség'],\n", " observation_ts,observation_th,prediction_ts,prediction_th)" ] }, { "cell_type": "code", "execution_count": 2417, "metadata": {}, "outputs": [], "source": [ "def setup_axes():\n", " fig,axes=plt.subplots(1,3,figsize=(8,5),gridspec_kw={'width_ratios': [1, 3, 1]})\n", " axi_top= axes[2].inset_axes([0.1, 0.65, 1, 0.3])\n", " axi_top.axis('off')\n", " axi_bottom= axes[2].inset_axes([0.1, 0, 1, 0.5])\n", " axi_bottom.axis('off')\n", " axes[0].axis('off')\n", " axes[1].axis('off')\n", " axes[2].axis('off')\n", " axes[0]=axes[0].inset_axes([0, 0.15, 1, 0.85])\n", " axes[1]=axes[1].inset_axes([0, 0.15, 1, 0.85])\n", " axes[0].axis('off')\n", " axes[1].axis('off')\n", " return fig, axes, axi_top, axi_bottom" ] }, { "cell_type": "code", "execution_count": 2418, "metadata": {}, "outputs": [], "source": [ "def stem_plot(data,ax,color,s=s):\n", " data=pd.DataFrame(data)\n", " x=data.index\n", " y=data[data.columns[0]].values\n", " for i,e in enumerate(y):\n", " ax.plot([0,e],[x[i],x[i]],color=color)\n", " ax.scatter(y,x,s,color=color,zorder=10)" ] }, { "cell_type": "code", "execution_count": 2419, "metadata": {}, "outputs": [], "source": [ "def stem2_plot(data,th,ax,color_left,color_right,s=s,axv_color=None):\n", " if axv_color==None:axv_color=color_right\n", " a1,a2,a3=get_data(data,th)\n", " stem_plot(a1,ax,color_left,s)\n", " stem_plot(a2,ax,color_right,s)\n", " ax.axvline(0,color=color_ax)\n", " #if th!=0:\n", " if True:\n", " ax.axvline(th,color=axv_color,ls='--',zorder=5)" ] }, { "cell_type": "code", "execution_count": 2666, "metadata": {}, "outputs": [], "source": [ "def icons_plot(axes,kondicio,mennyiseg,observation_th,prediction_th):\n", " ylim=axes[0].get_ylim()\n", " xlim=axes[1].get_xlim()\n", " y_max_coord=ylim[0]+(ylim[1]-ylim[0])*1.05\n", " y_max_coord2=ylim[0]+(ylim[1]-ylim[0])*1.05 #1.04\n", " x_icon_coord_shift=(xlim[1]-xlim[0])*0.1\n", " axes[0].text(observation_th, y_max_coord, title_icon[kondicio], \n", " horizontalalignment='center', color=color_obs_right0, fontproperties=prop2, fontsize=font_size*1.5)\n", " axes[1].text(prediction_th, y_max_coord, title_icon[mennyiseg], \n", " horizontalalignment='center', color=color_ax, fontproperties=prop2, fontsize=font_size*1.5)\n", " axes[1].text(prediction_th+x_icon_coord_shift, y_max_coord2, title_icon_right[mennyiseg], \n", " horizontalalignment='center', color=color_pred_right, fontproperties=prop2, fontsize=font_size*1.5)\n", " axes[1].text(prediction_th-x_icon_coord_shift, y_max_coord2, title_icon_left[mennyiseg], \n", " horizontalalignment='center', color=color_pred_left, fontproperties=prop2, fontsize=font_size*1.5)" ] }, { "cell_type": "code", "execution_count": 2667, "metadata": {}, "outputs": [], "source": [ "def talalat_plot_line(axes,n_prediction_ts_good,n_prediction_ts_bad,\n", " n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt,\n", " observation_th,prediction_th):\n", " ylim=axes[0].get_ylim()\n", " xlim=axes[0].get_xlim()\n", " y_max_coord=ylim[0]+(ylim[1]-ylim[0])*(-0.07)\n", " x_icon_coord_shift=(xlim[1]-xlim[0])*0.1\n", " x_icon_coord_shift2=(xlim[1]-xlim[0])*0.27\n", " axes[0].text(observation_th+x_icon_coord_shift, y_max_coord, obs_talalt_glyph, \n", " horizontalalignment='center', color=color_obs_right, fontproperties=prop2)\n", " axes[0].text(observation_th-x_icon_coord_shift, y_max_coord, obs_nem_talalt_glyph, \n", " horizontalalignment='center', color=color_obs_left, fontproperties=prop2)\n", " axes[0].text(observation_th+x_icon_coord_shift2, y_max_coord, n_prediction_ts_good, \n", " horizontalalignment='center', color=color_obs_right, fontproperties=prop)\n", " axes[0].text(observation_th-x_icon_coord_shift2, y_max_coord, n_prediction_ts_bad, \n", " horizontalalignment='center', color=color_obs_left, fontproperties=prop)\n", " axes[0].text(observation_th, y_max_coord, '|', \n", " horizontalalignment='center', color=color_obs_right0, fontproperties=prop,fontsize=19)\n", "\n", " xlim=axes[1].get_xlim()\n", " x_icon_coord_shift=(xlim[1]-xlim[0])*0.04\n", " x_icon_coord_shift2=(xlim[1]-xlim[0])*0.1\n", " axes[1].text(prediction_th+x_icon_coord_shift, y_max_coord, pred_talalt_glyph, \n", " horizontalalignment='center', color=color_pred_talalt, fontproperties=prop2)\n", " axes[1].text(prediction_th-x_icon_coord_shift, y_max_coord, pred_nem_talalt_glyph, \n", " horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop2)\n", " axes[1].text(prediction_th+x_icon_coord_shift2, y_max_coord, n_prediction_ts_good_talalt, \n", " horizontalalignment='center', color=color_pred_talalt, fontproperties=prop)\n", " axes[1].text(prediction_th-x_icon_coord_shift2, y_max_coord, n_prediction_ts_good_nem_talalt, \n", " horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop)\n", " axes[1].text(prediction_th, y_max_coord, '|', \n", " horizontalalignment='center', color=color_pred_right, fontproperties=prop,fontsize=19)\n", " \n", " y_max_coord=ylim[0]+(ylim[1]-ylim[0])*(-0.14)\n", " axes[0].text(observation_th, y_max_coord, 'feltétel', \n", " horizontalalignment='center', color=color_obs_right0, fontproperties=prop)\n", " axes[1].text(prediction_th, y_max_coord, 'jóslat', \n", " horizontalalignment='center', color=color_pred_right, fontproperties=prop)\n", " y_max_coord=ylim[0]+(ylim[1]-ylim[0])*(-0.13)\n", " x_coord_shift=prediction_th+(prediction_th-xlim[0])*(-0.4)\n", " axes[1].annotate('', xy=(x_coord_shift, y_max_coord),xycoords='data',annotation_clip=False,\n", " xytext=(xlim[0], y_max_coord),arrowprops=dict(arrowstyle= '->',color=color_obs_right0))" ] }, { "cell_type": "code", "execution_count": 2668, "metadata": {}, "outputs": [], "source": [ "def talalat_plot_violin(axes,n_prediction_ts_good,n_prediction_ts_bad,n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt):\n", " y_icon_obs=0.65\n", " y_icon_pred=0.5\n", " if color_obs_right==color_obs_right0: x=0.72\n", " else: x=0.47\n", " axes[2].text(0.72, y_icon_obs, obs_talalt_glyph, \n", " horizontalalignment='center', color=color_obs_right, fontproperties=prop2)\n", " axes[2].text(0.9, y_icon_obs,n_prediction_ts_good, \n", " horizontalalignment='center', color=color_obs_right, fontproperties=prop)\n", " axes[2].text(0.47, y_icon_obs, obs_nem_talalt_glyph, \n", " horizontalalignment='center', color=color_obs_left, fontproperties=prop2)\n", " axes[2].text(0.29, y_icon_obs, n_prediction_ts_bad, \n", " horizontalalignment='center', color=color_obs_left, fontproperties=prop)\n", " \n", " axes[2].text(0.72, y_icon_pred, pred_talalt_glyph,\n", " horizontalalignment='center', color=color_pred_talalt, fontproperties=prop2)\n", " axes[2].text(0.9, y_icon_pred, n_prediction_ts_good_talalt, \n", " horizontalalignment='center', color=color_pred_talalt, fontproperties=prop)\n", " axes[2].text(0.47, y_icon_pred, pred_nem_talalt_glyph, \n", " horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop2)\n", " axes[2].text(0.29, y_icon_pred, n_prediction_ts_good_nem_talalt,\n", " horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop)\n", " \n", " axes[2].annotate('', xy=(0.59, y_icon_pred*1.04),xycoords='data',\n", " xytext=(x, y_icon_obs*0.98),arrowprops=dict(arrowstyle= '->',color=color_obs_right0))" ] }, { "cell_type": "code", "execution_count": 2669, "metadata": {}, "outputs": [], "source": [ "def talalat_plot(axes,ns,observation_th,prediction_th):\n", " n_prediction_ts_good,n_prediction_ts_bad,n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt=ns\n", " talalat_plot_line(axes,n_prediction_ts_good,n_prediction_ts_bad,\n", " n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt,\n", " observation_th,prediction_th)\n", " talalat_plot_violin(axes,n_prediction_ts_good,n_prediction_ts_bad,\n", " n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt)" ] }, { "cell_type": "code", "execution_count": 2670, "metadata": {}, "outputs": [], "source": [ "def year_plot(data,ax,k):\n", " y=data.values\n", " x=data.index\n", " ex=max(y)-min(y)\n", " text_off=abs(ex*k)\n", " text_align='left'\n", " if y[0]<0:\n", " text_off=-text_off\n", " text_align='right'\n", " ax.text(y[0]+text_off, x[0], str(x[0]), \n", " horizontalalignment=text_align, verticalalignment='center', \n", " color=color_ax, fontproperties=prop)\n", " text_off=abs(text_off)\n", " text_align='left'\n", " if y[-1]<0:\n", " text_off=-text_off\n", " text_align='right'\n", " ax.text(y[-1]+text_off, x[-1], str(x[-1]), \n", " horizontalalignment=text_align, verticalalignment='center', \n", " color=color_ax, fontproperties=prop)" ] }, { "cell_type": "code", "execution_count": 2671, "metadata": {}, "outputs": [], "source": [ "def spine_plot(datum,title,mondas,jelentes,kondicio,mennyiseg,\n", " observation_ts,observation_th,prediction_ts,prediction_th):\n", " \n", " #data\n", " prediction_ts_good=prediction_ts.loc[observation_ts[observation_ts>observation_th].index]\n", " prediction_ts_bad=prediction_ts.loc[observation_ts[observation_ts<=observation_th].index]\n", " n_prediction_ts_good=len(prediction_ts_good)\n", " n_prediction_ts_bad=len(prediction_ts_bad)\n", " \n", " if color_obs_right0!=color_obs_right:\n", " prediction_ts_good,prediction_ts_bad=prediction_ts_bad,prediction_ts_good\n", " prediction_ts_good_nem_talalt,prediction_ts_good_talalt,\\\n", " prediction_ts_good_joined=get_data(prediction_ts_good,prediction_th)\n", " n_prediction_ts_good_talalt=len(prediction_ts_good_talalt)\n", " n_prediction_ts_good_nem_talalt=len(prediction_ts_good_nem_talalt)\n", " ns=[n_prediction_ts_good,n_prediction_ts_bad,n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt]\n", " \n", " #plots\n", " fig, axes, axi_top, axi_bottom=setup_axes()\n", " \n", " stem2_plot(observation_ts,observation_th,axes[0],color_obs_left,color_obs_right,s/2,color_obs_right0)\n", " stem2_plot(prediction_ts_good,prediction_th,axes[1],color_pred_left,color_pred_right)\n", " stem_plot(prediction_ts_bad,axes[1],color_ax)\n", " \n", " violin_plot(observation_ts,observation_th,axi_top,color_obs_left,color_obs_right)\n", " violin_plot(prediction_ts_good,prediction_th,axi_bottom,color_pred_left,color_pred_right)\n", " \n", " #icons\n", " icons_plot(axes,kondicio,mennyiseg,observation_th,prediction_th)\n", " \n", " #talalat\n", " talalat_plot(axes,ns,observation_th,prediction_th)\n", " \n", " #years\n", " year_plot(observation_ts,axes[0],0.09)\n", " year_plot(prediction_ts,axes[1],0.03)\n", " \n", " #titles\n", " len_ratio=0.15*(-1+(len(jelentes.split(',')[0])/len(jelentes.split(',')[1])))\n", " fig.text(0.5+len_ratio,0.04,jelentes.split(',')[0]+',',color=color_obs_right0,\n", " fontproperties=prop,fontsize=font_size*0.7,horizontalalignment='right')\n", " if color_pred_talalt==color_pred_talalt0: color_pred_side=color_pred_right\n", " else: color_pred_side=color_pred_left\n", " fig.text(0.5+len_ratio,0.04,jelentes.split(',')[1],color=color_pred_side,\n", " fontproperties=prop,fontsize=font_size*0.7,horizontalalignment='left')\n", " if n_prediction_ts_good_nem_talalt>=n_prediction_ts_good_talalt:\n", " color_title=color_pred_nem_talalt\n", " verdict=pred_nem_talalt_glyph\n", " else: \n", " color_title=color_pred_talalt\n", " verdict=pred_talalt_glyph\n", " plt.suptitle(title,y=0.11,color=color_title,fontproperties=prop,fontsize=font_size)\n", " fig.text(0.96,0.04,verdict, fontproperties=prop2,\n", " horizontalalignment='right', color=color_title, fontsize=font_size*2, )\n", " fig.text(0.04,0.045, datum, fontproperties=prop,\n", " horizontalalignment='left', color=color_obs_right0, fontsize=font_size*2, )\n", " \n", " plt.savefig(c+'/'+str(mondas)+'.png',dpi=300, facecolor=color_bg)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 2672, "metadata": {}, "outputs": [], "source": [ "def filter_data(dz,observation_range,prediction_range):\n", " dgs=[]\n", " dhs=[]\n", " for year in range(int(dz.min()['year']),int(dz.max()['year'])):\n", " k=0\n", " from_date=pd.to_datetime(str(year)+'-'+str(observation_range[k].month)+'-'+str(observation_range[k].day))\n", " from_pred=pd.to_datetime(str(year)+'-'+str(prediction_range[k].month)+'-'+str(prediction_range[k].day))\n", " k=1\n", " to_date=pd.to_datetime(str(year)+'-'+str(observation_range[k].month)+'-'+str(observation_range[k].day))\n", " to_pred=pd.to_datetime(str(year)+'-'+str(prediction_range[k].month)+'-'+str(prediction_range[k].day))\n", " if to_pred\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", " \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", " \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", "
XTEMPXSPDXPCPXSDXVSBYFOGYPCPYSNWYHALIDyearmonthdayhour
time
1952-01-012.5833332.8906250.000000NaN5.601500NaN0.6250000.0000000.0152287.50000019521.01.00.0
1952-01-022.5902787.4693750.762000NaN7.191375NaN0.3750000.3750000.0152562.50000019521.02.00.0
1952-01-031.9259263.8541670.000000NaN6.479400NaN0.3333330.0000000.0153150.00000019521.03.00.0
1952-01-042.3703704.9333331.828800NaN9.190500NaN0.3333330.3333330.0152995.00000019521.04.00.0
1952-01-051.04629612.9191670.719667NaN8.947500NaN0.1666670.1666670.5152311.66666719521.05.00.0
\n", "" ], "text/plain": [ " XTEMP XSPD XPCP XSD XVSB YFOG YPCP \\\n", "time \n", "1952-01-01 2.583333 2.890625 0.000000 NaN 5.601500 NaN 0.625000 \n", "1952-01-02 2.590278 7.469375 0.762000 NaN 7.191375 NaN 0.375000 \n", "1952-01-03 1.925926 3.854167 0.000000 NaN 6.479400 NaN 0.333333 \n", "1952-01-04 2.370370 4.933333 1.828800 NaN 9.190500 NaN 0.333333 \n", "1952-01-05 1.046296 12.919167 0.719667 NaN 8.947500 NaN 0.166667 \n", "\n", " YSNW YHAL ID year month day hour \n", "time \n", "1952-01-01 0.000000 0.0 152287.500000 1952 1.0 1.0 0.0 \n", "1952-01-02 0.375000 0.0 152562.500000 1952 1.0 2.0 0.0 \n", "1952-01-03 0.000000 0.0 153150.000000 1952 1.0 3.0 0.0 \n", "1952-01-04 0.333333 0.0 152995.000000 1952 1.0 4.0 0.0 \n", "1952-01-05 0.166667 0.5 152311.666667 1952 1.0 5.0 0.0 " ] }, "execution_count": 2673, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dz=df.groupby(['time']).mean()\n", "dz['year']=dz['year'].astype(int)\n", "dz.head()" ] }, { "cell_type": "code", "execution_count": 2674, "metadata": {}, "outputs": [], "source": [ "def set_direction(kondicio, mennyiseg):\n", " if kondicio:\n", " color_obs_right=color_obs_right0\n", " color_obs_left=color_obs_left0\n", " obs_talalt_glyph='★'\n", " obs_nem_talalt_glyph='☆'\n", " else:\n", " color_obs_right=color_obs_left0\n", " color_obs_left=color_obs_right0\n", " obs_talalt_glyph='☆'\n", " obs_nem_talalt_glyph='★'\n", " if mennyiseg:\n", " color_pred_talalt=color_pred_talalt0\n", " color_pred_nem_talalt=color_pred_nem_talalt0\n", " pred_talalt_glyph='✔️'\n", " pred_nem_talalt_glyph='✖️'\n", " else:\n", " color_pred_talalt=color_pred_nem_talalt0\n", " color_pred_nem_talalt=color_pred_talalt0\n", " pred_talalt_glyph='✖️'\n", " pred_nem_talalt_glyph='✔️'\n", " return color_obs_right,color_obs_left,obs_talalt_glyph,obs_nem_talalt_glyph,\\\n", " color_pred_talalt,color_pred_nem_talalt,pred_talalt_glyph,pred_nem_talalt_glyph" ] }, { "cell_type": "code", "execution_count": 2675, "metadata": {}, "outputs": [], "source": [ "def get_sign(sign,key):\n", " positive=True\n", " if (('-' in sign) or ('+' in sign)):\n", " if sign=='-':\n", " positive=False\n", " elif sign=='+':\n", " positive=True\n", " elif (('<' in sign) or ('>' in sign)):\n", " if '<' in sign:\n", " positive=False\n", " elif '>' in sign:\n", " positive=True\n", " return positive" ] }, { "cell_type": "code", "execution_count": 2676, "metadata": {}, "outputs": [], "source": [ "universal_normalize=['XTEMP','XVSB','XSPD']\n", "\n", "def get_ts_data(data,key,sign):\n", " ts=data.groupby('year').mean()[key]\n", " if (('-' in sign) or ('+' in sign)):\n", " th=ts.mean()\n", " else:\n", " th=float(sign[1:])\n", " if key in universal_normalize:\n", " th-=ts.mean() \n", " ts-=ts.mean()\n", " return ts,th" ] }, { "cell_type": "code", "execution_count": 2716, "metadata": {}, "outputs": [], "source": [ "def get_comp_data(observation_data,obs_key,obs_sign,prediction_data,pred_key,pred_sign):\n", " ertek_sign=True\n", " irany_sign=True\n", " observation_ts=observation_data.groupby('year').mean()[obs_key]\n", " prediction_ts=prediction_data.groupby('year').mean()[pred_key]\n", " prediction_th=observation_ts.mean()\n", " observation_ts-=observation_ts.mean()\n", " observation_th=observation_ts.min()*1.01\n", " prediction_th-=prediction_ts.mean()\n", " prediction_ts-=prediction_ts.mean() \n", " if obs_sign=='A':\n", " if pred_sign=='A':\n", " observation_th=0\n", " prediction_th=0\n", " else:\n", " irany_sign=False\n", " return observation_ts,observation_th,prediction_ts,prediction_th,ertek_sign,irany_sign" ] }, { "cell_type": "code", "execution_count": 2717, "metadata": {}, "outputs": [], "source": [ "mennyiseg_key={'Temp':'XTEMP','Snow Depth':'XSD','Wind':'XSPD','Rain':'YPCP','Visib':'XVSB',\n", " 'Snow':'YSNW','Hail':'YHAL'}" ] }, { "cell_type": "code", "execution_count": 2718, "metadata": {}, "outputs": [], "source": [ "nepi=pd.read_excel(c+'/idojaras_'+c+'.xlsx')" ] }, { "cell_type": "code", "execution_count": 2721, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "55\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "mondasok=nepi['ID'].values\n", "# mondasok=range(60,61)\n", "mondasok=[55]\n", "for mondas in mondasok:\n", " nep=nepi.loc[mondas]\n", " if str(nep['Mennyiség'])!='nan':\n", " print(mondas)\n", " obs_key=mennyiseg_key[nep['Kondíció']]\n", " pred_key=mennyiseg_key[nep['Mennyiség']]\n", " observation_range=[nep['Dátum:mettől']+pd.to_timedelta('-1D'),nep['Dátum:meddig']+pd.to_timedelta('+2D')]\n", " prediction_range=[nep['Periódus:mettől'],nep['Periódus:meddig']+pd.to_timedelta('+1D')]\n", " observation_data,prediction_data=filter_data(dz,observation_range,prediction_range)\n", "\n", " #comparison\n", " if str(nep['Érték']) in ['A','B']:\n", " observation_ts,observation_th,prediction_ts,prediction_th,ertek_sign,irany_sign=\\\n", " get_comp_data(observation_data,obs_key,nep['Érték'],\\\n", " prediction_data,pred_key,nep['Irány'])\n", " #time series\n", " else:\n", " ertek_sign=get_sign(nep['Érték'],obs_key)\n", " irany_sign=get_sign(nep['Irány'],pred_key)\n", " observation_ts,observation_th=get_ts_data(observation_data,obs_key,nep['Érték'])\n", " prediction_ts,prediction_th=get_ts_data(prediction_data,pred_key,nep['Irány'])\n", " \n", " color_obs_right,color_obs_left,obs_talalt_glyph,obs_nem_talalt_glyph,\\\n", " color_pred_talalt,color_pred_nem_talalt,pred_talalt_glyph,pred_nem_talalt_glyph=\\\n", " set_direction(ertek_sign, irany_sign)\n", "\n", " datum=str(nep['Dátum:mettől'].month)+'.'+str(nep['Dátum:mettől'].day)+'.'\n", " datum=str(nep['Dátums'])[:3]+'. '+str(nep['Dátum:mettől'].day)\n", " spine_plot(datum,nep['Mondás'].strip(),mondas,nep['Jelentés'].strip(),nep['Kondíció'],nep['Mennyiség'],\n", " observation_ts,observation_th,prediction_ts,prediction_th)" ] } ], "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.7.4" } }, "nbformat": 4, "nbformat_minor": 4 }