def get_stats(df): df_stat = df.dropna() sim = df_stat.iloc[:, 0].to_numpy() obd = df_stat.iloc[:, 1].to_numpy() df_nse = evaluator(nse, sim, obd)[0] df_rmse = evaluator(rmse, sim, obd)[0] df_pibas = evaluator(pbias, sim, obd)[0] r_squared = (((sum((obd - obd.mean()) * (sim - sim.mean())))**2) / ((sum( (obd - obd.mean())**2) * (sum((sim - sim.mean())**2))))) return df_nse, df_rmse, df_pibas, r_squared
def Update_performance_table(link, Event): #Read the observed data Qo = pd.read_msgpack('BaseData/USGS/'+str(link)+'.msg') Qsim = {} Performance = {'QpDiff': {}, 'TpDiff': {}, 'Kling-Gupta':{}} for lambdas in ['005','01','015','02','025']: #try: #Read the data path = 'Results/'+str(link)+'_'+lambdas+'_'+str(Event)+'.csv' Qs = pd.read_csv(path, index_col = 0, skiprows=0, parse_dates=True) Qsim.update({lambdas : Qs['Qsim'].resample('30min').mean()}) Qo = Qo[Qs.resample('30min').mean().index] #Obtains best lambda in terms of the peak mag and timming Performance['QpDiff'].update({lambdas: np.abs(Qs['Qsim'].max() - Qo.max())}) Td = Qs['Qsim'].idxmax() - Qo.idxmax() Performance['TpDiff'].update({lambdas: np.abs(Td.total_seconds()) / 3600.}) pos = np.where((np.isfinite(Qsim[lambdas].values)) & (np.isfinite(Qo.values)))[0] Performance['Kling-Gupta'].update({lambdas: heval.evaluator(heval.kge, Qsim[lambdas].values[pos], Qo.values[pos])[0][0]}) #except: # pass Performance = pd.DataFrame.from_dict(Performance) D = Performance.round(2).to_dict('records', ) for c,k in enumerate(['005','01','015','02','025']): D[c].update({'Lambda1':k}) return D
def nse(x, x_0): nse = he.evaluator(he.nse, simulation_s=np.array(list(x.values())), evaluation=np.array(list(x_0.values())))[0] print("nse ", nse) # make record with open(os.path.join(temp_path, "NSEs_" + dbid + ".txt"), "a") as nse_file: nse_file.write(str(nse) + "\n") return nse
#Read the data path = 'Results/' + args.link + '_' + lambdas + '_' + str( Event) + '.csv' Qs = pd.read_csv(path, index_col=0, skiprows=0, parse_dates=True) Qsim.update({lambdas: Qs['Qsim'].resample('30min').mean()}) Qo = Qobs[Qs.resample('30min').mean().index] #Obtains best lambda in terms of the peak mag and timming Performance['qpeak'].update( {lambdas: np.abs(Qs['Qsim'].max() - Qo.max())}) Td = Qs['Qsim'].idxmax() - Qo.idxmax() Performance['time'].update( {lambdas: np.abs(Td.total_seconds()) / 3600.}) pos = np.where((np.isfinite(Qsim[lambdas].values)) & (np.isfinite(Qo.values)))[0] Performance['kg'].update({ lambdas: heval.evaluator(heval.kge, Qsim[lambdas].values[pos], Qo.values[pos])[0][0] }) except: Performance['qpeak'].update({lambdas: np.nan}) Performance['time'].update({lambdas: np.nan}) Performance['kg'].update({lambdas: np.nan}) BigPerf.update({str(Event): Performance}) #Saves the json of that link j = json.dumps(BigPerf) f = open("Summary/" + args.link + '_summary.json', "w") f.write(j) f.close()
def Plot_event(link, Event, obj_func): #Read the observed data Qo = pd.read_msgpack('BaseData/USGS/'+str(link)+'.msg') Qsim = {} Performance = {'qpeak': {}, 'time': {}, 'kg':{}} for lambdas in ['005','01','015','02','025']: #try: #Read the data path = 'Results/'+str(link)+'_'+lambdas+'_'+str(Event)+'.csv' Qs = pd.read_csv(path, index_col = 0, skiprows=0, parse_dates=True) Qsim.update({lambdas : Qs['Qsim'].resample('30min').mean()}) Qo = Qo[Qs.resample('30min').mean().index] #Obtains best lambda in terms of the peak mag and timming Performance['qpeak'].update({lambdas: np.abs(Qs['Qsim'].max() - Qo.max())}) Td = Qs['Qsim'].idxmax() - Qo.idxmax() Performance['time'].update({lambdas: np.abs(Td.total_seconds()) / 3600.}) pos = np.where((np.isfinite(Qsim[lambdas].values)) & (np.isfinite(Qo.values)))[0] Performance['kg'].update({lambdas: heval.evaluator(heval.kge, Qsim[lambdas].values[pos], Qo.values[pos])[0][0]}) #except: # pass Performance = pd.DataFrame.from_dict(Performance) #Select wich to plot in function of the objetive if obj_func == 'Lower Qpeak difference': Best = Performance['qpeak'].idxmin() elif obj_func == 'Lower timming at the Qpeak': Best = Performance['time'].idxmin() elif obj_func == 'Best KG': Best = Performance['kg'].idxmax() #Plot the events data = [] for k in ['005','01','015','02','025']: if k != Best: trace = go.Scatter( x = Qsim[k].index, y = Qsim[k].values, name = k, line = dict( width = 4, color = 'rgb(192,192,192)' ) ) data.append(trace) #Plot the best event trace = go.Scatter( x = Qsim[Best].index, y = Qsim[Best].values, name = Best, line = dict( width = 5, color = 'rgb(0,102,204)' ) ) data.append(trace) #Plot the observed data trace = go.Scatter( x = Qo.index, y = Qo.values, name = 'Observed', mode = 'markers', marker = dict( color = 'rgb(0,0,0)', ) ) data.append(trace) #The set up of the figure layout = dict( xaxis = dict( title = 'Time [30min]', titlefont = dict( size = 18 ), tickfont = dict( size = 16 ) ), yaxis = dict( title = 'Streamflow [m3s-1]', titlefont = dict( size = 18 ), tickfont = dict( size = 16 ) ), margin=go.layout.Margin( l=50, r=50, b=100, t=20, pad=4 ), ) return { 'data': data, 'layout': layout }
# notations indicating an outlier ax.annotate('Outlier', xy=(190, 105), xytext=(183, 102), arrowprops=dict(arrowstyle='->', ec='grey', lw=2), bbox=dict(boxstyle="round", fc="0.8")) ax.annotate('Outlier', xy=(165, 85), xytext=(158, 82), arrowprops=dict(arrowstyle='->', ec='grey', lw=2), bbox=dict(boxstyle="round", fc="0.8")) # NSE, R2 calculation r2 = (np.corrcoef(df_flow['obs'], df_flow['sim']))[0, 1]**2 r2_val = round(r2, 3) nse = he.evaluator(he.nse, np.array(df_flow['obs']), np.array(df_flow['sim'])) nse_val = round(nse[0], 3) # labels and title lims = (0, max(df_flow.max())) # ax.set(xlim=lims, ylim=lims) plt.xlabel('Simulation', fontsize=14) plt.ylabel('Observation', fontsize=14) plt.title('Relation between obs. and sim.', fontsize=15) # write r2, nse in the graph plt.text(1, lims[1] * 0.9, r'$R^2: $' + str(r2_val), fontdict={'size': 12}) plt.text(1, lims[1] * 0.85, r'$NSE: $' + str(nse_val), fontdict={'size': 12}) plt.show()
for d in range(len(sim_list_2)): c.write(str(sim_list_2[d]) + "\n") c.close() # CALCULATE EFFICIENCY STATISTICS # import and check Hobs_18_volume = numpy.loadtxt(fname=obsdata_filename_1) sim_output_H = numpy.loadtxt(fname=simdata_filename_1) Pobs_18_volume = numpy.loadtxt(fname=obsdata_filename_2) sim_output_P = numpy.loadtxt(fname=simdata_filename_2) #if not numpy.array_equal(Hobs_18_volume, sim_output_H): #raise Exception('The observed and simulated periods (time series length) do not match. ' + str(len(Hobs_18_volume)) + "," + str(len(sim_output_H))) # calculate - hen H_nse = evaluator(nse, sim_output_H, Hobs_18_volume) H_pbias = evaluator(pbias, sim_output_H, Hobs_18_volume) H_rmse = evaluator(rmse, sim_output_H, Hobs_18_volume) sd_1 = stdev(Hobs_18_volume) H_rsr = H_rmse / sd_1 H_linr = stats.linregress(Hobs_18_volume, sim_output_H) H_r2 = H_linr[2]**2 # calculate - plume P_nse = evaluator(nse, sim_output_P, Pobs_18_volume) P_pbias = evaluator(pbias, sim_output_P, Pobs_18_volume) P_rmse = evaluator(rmse, sim_output_P, Pobs_18_volume) sd_2 = stdev(Pobs_18_volume) P_rsr = P_rmse / sd_2 P_linr = stats.linregress(Pobs_18_volume, sim_output_P) P_r2 = P_linr[2]**2
b = open("C:/AGNPS_Watershed_Studies/Bunny_Pothole_Model_Volume/9_BAN_calibration/Python_Output/sim_output_volume.txt", "w+").close() b = open("C:/AGNPS_Watershed_Studies/Bunny_Pothole_Model_Volume/9_BAN_calibration/Python_Output/sim_output_volume.txt", "w+") for z in range(len(sim_list)): b.write(str(sim_list[z])+"\n") b.close() # CALCULATE EFFICIENCY STATISTICS # import and check Bobs_16_18_volume = numpy.loadtxt(fname = obsdata_filename) # object is named: B for bunny, obs for 'observed' and then years of data, and metric sim_output = numpy.loadtxt(fname = simdata_filename) #if not numpy.array_equal(Bobs_16_18_volume, sim_output): #raise Exception('The observed and simulated periods (time series length) do not match. ' + str(len(Bobs_16_18_volume)) + "," + str(len(sim_output))) # calculate b_nse = evaluator(nse, sim_output, Bobs_16_18_volume) # b for bunny, and nse for Nash Sutcliffe efficiency b_pbias = evaluator(pbias, sim_output, Bobs_16_18_volume) # percent bias b_rmse = evaluator(rmse, sim_output, Bobs_16_18_volume) # rmse sd = stdev(Bobs_16_18_volume) # standard deviation b_rsr = b_rmse / sd # RSR b_linr = stats.linregress(Bobs_16_18_volume, sim_output) b_r2 = b_linr[2]**2 # R^2 # WRITE STATISTICS TO SUMMARY FILE trialdata = str(i) + "," + str(A_min) + ".," + str(B_min) + ".," + str(C_min) + ".," + str(D_min) + ".," + str(inf_min) + "," + str(b_nse) + "," + str(b_pbias) + "," + str(b_rsr) + "," + str(b_r2) + "\n" s = open(statssum_filename, "a") s.write(trialdata) s.close() # increment i = i + 1 # next model run
def wt_plot(plot_df): colnams = plot_df.columns.tolist() # plot fig, ax = plt.subplots(figsize=(12, 4)) ax.grid(True) ax.plot(plot_df.index, plot_df.iloc[:, 0], label='Simulated', color='green', marker='^', alpha=0.7) ax.scatter( plot_df.index, plot_df.iloc[:, 1], label='Observed', # color='red', facecolors="None", edgecolors='red', lw=1.5, alpha=0.4, # zorder=2, ) ax.plot( plot_df.index, plot_df.iloc[:, 1], color='red', alpha=0.4, zorder=2, ) ax2 = ax.twinx() ax2.bar(plot_df.index, plot_df.prep, label='Precipitation', width=20, color="blue", align='center', alpha=0.5, zorder=0) ax2.set_ylabel("Precipitation $(mm)$", color="blue", fontsize=14) ax.set_ylabel("Depth to Water $(m)$", fontsize=14) ax2.invert_yaxis() ax2.set_ylim(plot_df.prep.max() * 3, 0) ax.margins(y=0.2) ax.tick_params(axis='both', labelsize=12) ax2.tick_params(axis='y', labelsize=12) # add stats plot_df = plot_df.drop('prep', axis=1) org_stat = plot_df.dropna() sim_org = org_stat.iloc[:, 0].to_numpy() obd_org = org_stat.iloc[:, 1].to_numpy() df_nse = evaluator(nse, sim_org, obd_org) df_rmse = evaluator(rmse, sim_org, obd_org) df_pibas = evaluator(pbias, sim_org, obd_org) r_squared = (((sum( (obd_org - obd_org.mean()) * (sim_org - sim_org.mean())))**2) / ((sum( (obd_org - obd_org.mean())**2) * (sum( (sim_org - sim_org.mean())**2))))) ax.text(0.95, 0.05, 'NSE: {:.2f} | RMSE: {:.2f} | PBIAS: {:.2f} | R-Squared: {:.2f}'. format(df_nse[0], df_rmse[0], df_pibas[0], r_squared), horizontalalignment='right', fontsize=10, bbox=dict(facecolor='green', alpha=0.5), transform=ax.transAxes) ax.set_title(colnams[0], loc='center', fontsize=12) fig.tight_layout() lines, labels = fig.axes[0].get_legend_handles_labels() ax.legend( lines, labels, loc='lower left', ncol=5, # bbox_to_anchor=(0, 0.202), fontsize=12) # plt.legend() plt.show()
j2K_daily_ice_contribution = (time_loop['iceRunoff'] / time_loop['catchmentSimRunoff']) * 100 j2K_monthly_ice_contribution = j2K_daily_ice_contribution.resample('M').mean() j2k_annual_ice_contribution = j2K_daily_ice_contribution.resample('Y').mean() j2K_daily_glacier_contribution = (time_loop['glacierRunoff'] / time_loop['catchmentSimRunoff']) * 100 j2K_monthly_glacier_contribution = j2K_daily_glacier_contribution.resample( 'M').mean() j2k_annual_glacier_contribution = j2K_daily_glacier_contribution.resample( 'Y').mean() ############# COMPUTE J2K PERFORMANCE ############## ### Kling-Gupta Efficiency (objective function 1) kge_j2k = evaluator(kge, time_loop['catchmentSimRunoff'].values, arvan_obs['runoff'].values)[0][0] kge_j2k_no_glacier = evaluator(kge, time_loop['noGlacierRunoff'].values, arvan_obs['runoff'].values)[0][0] # Nash-Sutcliffe Efficiency (nse) nse_j2k = evaluator(nse, time_loop['catchmentSimRunoff'].values, arvan_obs['runoff'].values)[0] nse_j2k_no_glacier = evaluator(nse, time_loop['noGlacierRunoff'].values, arvan_obs['runoff'].values)[0] print("\nJ2K KGE with glacier: " + str(kge_j2k)) print("\nJ2K NSE with glacier: " + str(nse_j2k)) print("\nJ2K KGE without glacier: " + str(kge_j2k_no_glacier)) print("\nJ2K NSE without glacier: " + str(nse_j2k_no_glacier))