def test_refreezing_parametrisation(): water_content_before = np.nansum(GRID.get_liquid_water_content()) water_refreezed = refreezing(GRID) #assert water_content_before == np.nansum(GRID.get_liquid_water_content()) + water_refreezed
def cosipy_core(DATA, indY, indX, GRID_RESTART=None, stake_names=None, stake_data=None): """ Cosipy core function, which perform the calculations on one core. Params ====== DATA: xarray.Dataset xarray dataset which contain one grid point indY: indX: GRID_RESTART : boolean, optional If restart is given, no inital profile is created stake_name : boolean, optional stake names stake_data : boolean, optional stake data Returns ====== Returns all calculated variables of one grid point """ # Replace values from constants.py if coupled from constants import max_layers, dt, z #WTF python! if WRF_X_CSPY: dt = int(DATA.DT.values) max_layers = int(DATA.max_layers.values) z = float(DATA.ZLVL.values) # Local variables nt = len(DATA.time.values) #accessing DATA is expensive _RRR = np.full(nt, np.nan) _RAIN = np.full(nt, np.nan) _SNOWFALL = np.full(nt, np.nan) _LWin = np.full(nt, np.nan) _LWout = np.full(nt, np.nan) _H = np.full(nt, np.nan) _LE = np.full(nt, np.nan) _B = np.full(nt, np.nan) _QRR = np.full(nt, np.nan) _MB = np.full(nt, np.nan) _surfMB = np.full(nt, np.nan) _MB = np.full(nt, np.nan) _Q = np.full(nt, np.nan) _SNOWHEIGHT = np.full(nt, np.nan) _TOTALHEIGHT = np.full(nt, np.nan) _TS = np.full(nt, np.nan) _ALBEDO = np.full(nt, np.nan) _ME = np.full(nt, np.nan) _intMB = np.full(nt, np.nan) _EVAPORATION = np.full(nt, np.nan) _SUBLIMATION = np.full(nt, np.nan) _CONDENSATION = np.full(nt, np.nan) _DEPOSITION = np.full(nt, np.nan) _REFREEZE = np.full(nt, np.nan) _NLAYERS = np.full(nt, np.nan) _subM = np.full(nt, np.nan) _Z0 = np.full(nt, np.nan) _surfM = np.full(nt, np.nan) _MOL = np.full(nt, np.nan) _LAYER_HEIGHT = np.full((nt, max_layers), np.nan) _LAYER_RHO = np.full((nt, max_layers), np.nan) _LAYER_T = np.full((nt, max_layers), np.nan) _LAYER_LWC = np.full((nt, max_layers), np.nan) _LAYER_CC = np.full((nt, max_layers), np.nan) _LAYER_POROSITY = np.full((nt, max_layers), np.nan) _LAYER_ICE_FRACTION = np.full((nt, max_layers), np.nan) _LAYER_IRREDUCIBLE_WATER = np.full((nt, max_layers), np.nan) _LAYER_REFREEZE = np.full((nt, max_layers), np.nan) #-------------------------------------------- # Initialize snowpack or load restart grid #-------------------------------------------- if GRID_RESTART is None: GRID = init_snowpack(DATA) else: GRID = load_snowpack(GRID_RESTART) # Create the local output datasets if not coupled RESTART = None if not WRF_X_CSPY: IO = IOClass(DATA) RESTART = IO.create_local_restart_dataset() # hours since the last snowfall (albedo module) hours_since_snowfall = 0 #-------------------------------------------- # Get data from file #-------------------------------------------- T2 = DATA.T2.values RH2 = DATA.RH2.values PRES = DATA.PRES.values G = DATA.G.values U2 = DATA.U2.values #-------------------------------------------- # Checks for optional input variables #-------------------------------------------- if ('SNOWFALL' in DATA) and ('RRR' in DATA): SNOWF = DATA.SNOWFALL.values * mult_factor_RRR RRR = DATA.RRR.values * mult_factor_RRR elif ('SNOWFALL' in DATA): SNOWF = DATA.SNOWFALL.values * mult_factor_RRR RRR = None RAIN = None else: SNOWF = None RRR = DATA.RRR.values * mult_factor_RRR # Use RRR rather than snowfall? if force_use_TP: SNOWF = None if ('LWin' in DATA) and ('N' in DATA): LWin = DATA.LWin.values N = DATA.N.values elif ('LWin' in DATA): LWin = DATA.LWin.values else: LWin = None N = DATA.N.values # Use N rather than LWin if force_use_N: LWin = None if ('SLOPE' in DATA): SLOPE = DATA.SLOPE.values else: SLOPE = 0.0 # Initial cumulative mass balance variable MB_cum = 0 if stake_evaluation: # Create pandas dataframe for stake evaluation _df = pd.DataFrame(index=stake_data.index, columns=['mb', 'snowheight'], dtype='float') #-------------------------------------------- # TIME LOOP #-------------------------------------------- for t in np.arange(nt): # Check grid GRID.grid_check() # get seconds since start timestamp = dt * t if WRF_X_CSPY: timestamp = np.float64(DATA.CURR_SECS.values) # Calc fresh snow density if (densification_method != 'constant'): density_fresh_snow = np.maximum( 109.0 + 6.0 * (T2[t] - 273.16) + 26.0 * np.sqrt(U2[t]), 50.0) else: density_fresh_snow = constant_density # Derive snowfall [m] and rain rates [m w.e.] if (SNOWF is not None) and (RRR is not None): SNOWFALL = SNOWF[t] RAIN = RRR[t] - SNOWFALL * (density_fresh_snow / ice_density) * 1000.0 elif (SNOWF is not None): SNOWFALL = SNOWF[t] else: # Else convert total precipitation [mm] to snowheight [m]; liquid/solid fraction SNOWFALL = (RRR[t] / 1000.0) * ( ice_density / density_fresh_snow) * (0.5 * (-np.tanh( ((T2[t] - zero_temperature) - center_snow_transfer_function ) * spread_snow_transfer_function) + 1.0)) RAIN = RRR[t] - SNOWFALL * (density_fresh_snow / ice_density) * 1000.0 # if snowfall is smaller than the threshold if SNOWFALL < minimum_snowfall: SNOWFALL = 0.0 # if rainfall is smaller than the threshold if RAIN < (minimum_snowfall * (density_fresh_snow / ice_density) * 1000.0): RAIN = 0.0 if SNOWFALL > 0.0: # Add a new snow node on top GRID.add_fresh_snow(SNOWFALL, density_fresh_snow, np.minimum(float(T2[t]), zero_temperature), 0.0) else: GRID.set_fresh_snow_props_update_time(dt) # Guarantee that solar radiation is greater equal zero if (G[t] < 0.0): G[t] = 0.0 #-------------------------------------------- # Merge grid layers, if necessary #-------------------------------------------- GRID.update_grid() #-------------------------------------------- # Calculate albedo and roughness length changes if first layer is snow #-------------------------------------------- alpha = updateAlbedo(GRID) #-------------------------------------------- # Update roughness length #-------------------------------------------- z0 = updateRoughness(GRID) #-------------------------------------------- # Surface Energy Balance #-------------------------------------------- # Calculate net shortwave radiation SWnet = G[t] * (1 - alpha) # Penetrating SW radiation and subsurface melt if SWnet > 0.0: subsurface_melt, G_penetrating = penetrating_radiation( GRID, SWnet, dt) else: subsurface_melt = 0.0 G_penetrating = 0.0 # Calculate residual net shortwave radiation (penetrating part removed) sw_radiation_net = SWnet - G_penetrating if LWin is not None: # Find new surface temperature (LW is used from the input file) fun, surface_temperature, lw_radiation_in, lw_radiation_out, sensible_heat_flux, latent_heat_flux, \ ground_heat_flux, rain_heat_flux, rho, Lv, MOL, Cs_t, Cs_q, q0, q2 \ = update_surface_temperature(GRID, dt, z, z0, T2[t], RH2[t], PRES[t], sw_radiation_net, U2[t], RAIN, SLOPE, LWin=LWin[t]) else: # Find new surface temperature (LW is parametrized using cloud fraction) fun, surface_temperature, lw_radiation_in, lw_radiation_out, sensible_heat_flux, latent_heat_flux, \ ground_heat_flux, rain_heat_flux, rho, Lv, MOL, Cs_t, Cs_q, q0, q2 \ = update_surface_temperature(GRID, dt, z, z0, T2[t], RH2[t], PRES[t], sw_radiation_net, U2[t], RAIN, SLOPE, N=N[t]) #-------------------------------------------- # Surface mass fluxes [m w.e.q.] #-------------------------------------------- if surface_temperature < zero_temperature: sublimation = min( latent_heat_flux / (water_density * lat_heat_sublimation), 0) * dt deposition = max( latent_heat_flux / (water_density * lat_heat_sublimation), 0) * dt evaporation = 0 condensation = 0 else: sublimation = 0 deposition = 0 evaporation = min( latent_heat_flux / (water_density * lat_heat_vaporize), 0) * dt condensation = max( latent_heat_flux / (water_density * lat_heat_vaporize), 0) * dt #-------------------------------------------- # Melt process - mass changes of snowpack (melting, sublimation, deposition, evaporation, condensation) #-------------------------------------------- # Melt energy in [W m^-2 or J s^-1 m^-2] melt_energy = max( 0, sw_radiation_net + lw_radiation_in + lw_radiation_out + ground_heat_flux + rain_heat_flux + sensible_heat_flux + latent_heat_flux) # Convert melt energy to m w.e.q. melt = melt_energy * dt / (1000 * lat_heat_melting) # Remove melt [m w.e.q.] lwc_from_melted_layers = GRID.remove_melt_weq(melt - sublimation - deposition) #-------------------------------------------- # Percolation #-------------------------------------------- Q = percolation( GRID, melt + condensation + RAIN / 1000.0 + lwc_from_melted_layers, dt) #-------------------------------------------- # Refreezing #-------------------------------------------- water_refreezed = refreezing(GRID) #-------------------------------------------- # Solve the heat equation #-------------------------------------------- solveHeatEquation(GRID, dt) #-------------------------------------------- # Calculate new density to densification #-------------------------------------------- densification(GRID, SLOPE, dt) #-------------------------------------------- # Calculate mass balance #-------------------------------------------- surface_mass_balance = SNOWFALL * ( density_fresh_snow / ice_density) - melt + sublimation + deposition + evaporation internal_mass_balance = water_refreezed - subsurface_melt mass_balance = surface_mass_balance + internal_mass_balance internal_mass_balance2 = melt - Q + subsurface_melt mass_balance_check = surface_mass_balance + internal_mass_balance2 # Cumulative mass balance for stake evaluation MB_cum = MB_cum + mass_balance # Store cumulative MB in pandas frame for validation if stake_names: if (DATA.isel(time=t).time.values in stake_data.index): _df['mb'].loc[DATA.isel(time=t).time.values] = MB_cum _df['snowheight'].loc[DATA.isel( time=t).time.values] = GRID.get_total_snowheight() # Save results _RAIN[t] = RAIN _SNOWFALL[t] = SNOWFALL * (density_fresh_snow / ice_density) _LWin[t] = lw_radiation_in _LWout[t] = lw_radiation_out _H[t] = sensible_heat_flux _LE[t] = latent_heat_flux _B[t] = ground_heat_flux _QRR[t] = rain_heat_flux _MB[t] = mass_balance _surfMB[t] = surface_mass_balance _Q[t] = Q _SNOWHEIGHT[t] = GRID.get_total_snowheight() _TOTALHEIGHT[t] = GRID.get_total_height() _TS[t] = surface_temperature _ALBEDO[t] = alpha _NLAYERS[t] = GRID.get_number_layers() _ME[t] = melt_energy _intMB[t] = internal_mass_balance _EVAPORATION[t] = evaporation _SUBLIMATION[t] = sublimation _CONDENSATION[t] = condensation _DEPOSITION[t] = deposition _REFREEZE[t] = water_refreezed _subM[t] = subsurface_melt _Z0[t] = z0 _surfM[t] = melt _MOL[t] = MOL if full_field: if GRID.get_number_layers() > max_layers: print('Maximum number of layers reached') else: _LAYER_HEIGHT[t, 0:GRID.get_number_layers()] = GRID.get_height() _LAYER_RHO[t, 0:GRID.get_number_layers()] = GRID.get_density() _LAYER_T[t, 0:GRID.get_number_layers()] = GRID.get_temperature() _LAYER_LWC[t, 0:GRID.get_number_layers( )] = GRID.get_liquid_water_content() _LAYER_CC[ t, 0:GRID.get_number_layers()] = GRID.get_cold_content() _LAYER_POROSITY[ t, 0:GRID.get_number_layers()] = GRID.get_porosity() _LAYER_ICE_FRACTION[ t, 0:GRID.get_number_layers()] = GRID.get_ice_fraction() _LAYER_IRREDUCIBLE_WATER[t, 0:GRID.get_number_layers( )] = GRID.get_irreducible_water_content() _LAYER_REFREEZE[ t, 0:GRID.get_number_layers()] = GRID.get_refreeze() else: _LAYER_HEIGHT = None _LAYER_RHO = None _LAYER_T = None _LAYER_LWC = None _LAYER_CC = None _LAYER_POROSITY = None _LAYER_ICE_FRACTION = None _LAYER_IRREDUCIBLE_WATER = None _LAYER_REFREEZE = None if stake_evaluation: # Evaluate stakes _stat = evaluate(stake_names, stake_data, _df) else: _stat = None _df = None # Restart if not WRF_X_CSPY: new_snow_height, new_snow_timestamp, old_snow_timestamp = GRID.get_fresh_snow_props( ) RESTART.NLAYERS.values[:] = GRID.get_number_layers() RESTART.NEWSNOWHEIGHT.values[:] = new_snow_height RESTART.NEWSNOWTIMESTAMP.values[:] = new_snow_timestamp RESTART.OLDSNOWTIMESTAMP.values[:] = old_snow_timestamp RESTART.LAYER_HEIGHT[0:GRID.get_number_layers()] = GRID.get_height() RESTART.LAYER_RHO[0:GRID.get_number_layers()] = GRID.get_density() RESTART.LAYER_T[0:GRID.get_number_layers()] = GRID.get_temperature() RESTART.LAYER_LWC[0:GRID.get_number_layers( )] = GRID.get_liquid_water_content() RESTART.LAYER_IF[0:GRID.get_number_layers()] = GRID.get_ice_fraction() return (indY,indX,RESTART,_RAIN,_SNOWFALL,_LWin,_LWout,_H,_LE,_B, _QRR, \ _MB,_surfMB,_Q,_SNOWHEIGHT,_TOTALHEIGHT,_TS,_ALBEDO,_NLAYERS, \ _ME,_intMB,_EVAPORATION,_SUBLIMATION,_CONDENSATION,_DEPOSITION,_REFREEZE, \ _subM,_Z0,_surfM, _MOL, \ _LAYER_HEIGHT,_LAYER_RHO,_LAYER_T,_LAYER_LWC,_LAYER_CC,_LAYER_POROSITY,_LAYER_ICE_FRACTION, \ _LAYER_IRREDUCIBLE_WATER,_LAYER_REFREEZE,stake_names,_stat,_df)
def cosipy_core(DATA, indY, indX, GRID_RESTART=None, stake_names=None, stake_data=None): # Local variables _RRR = np.full(len(DATA.time), np.nan) _RAIN = np.full(len(DATA.time), np.nan) _SNOWFALL = np.full(len(DATA.time), np.nan) _LWin = np.full(len(DATA.time), np.nan) _LWout = np.full(len(DATA.time), np.nan) _H = np.full(len(DATA.time), np.nan) _LE = np.full(len(DATA.time), np.nan) _B = np.full(len(DATA.time), np.nan) _MB = np.full(len(DATA.time), np.nan) _surfMB = np.full(len(DATA.time), np.nan) _MB = np.full(len(DATA.time), np.nan) _Q = np.full(len(DATA.time), np.nan) _SNOWHEIGHT = np.full(len(DATA.time), np.nan) _TOTALHEIGHT = np.full(len(DATA.time), np.nan) _TS = np.full(len(DATA.time), np.nan) _ALBEDO = np.full(len(DATA.time), np.nan) _ME = np.full(len(DATA.time), np.nan) _intMB = np.full(len(DATA.time), np.nan) _EVAPORATION = np.full(len(DATA.time), np.nan) _SUBLIMATION = np.full(len(DATA.time), np.nan) _CONDENSATION = np.full(len(DATA.time), np.nan) _DEPOSITION = np.full(len(DATA.time), np.nan) _REFREEZE = np.full(len(DATA.time), np.nan) _NLAYERS = np.full(len(DATA.time), np.nan) _subM = np.full(len(DATA.time), np.nan) _Z0 = np.full(len(DATA.time), np.nan) _surfM = np.full(len(DATA.time), np.nan) _LAYER_HEIGHT = np.full((len(DATA.time),max_layers), np.nan) _LAYER_RHO = np.full((len(DATA.time),max_layers), np.nan) _LAYER_T = np.full((len(DATA.time),max_layers), np.nan) _LAYER_LWC = np.full((len(DATA.time),max_layers), np.nan) _LAYER_CC = np.full((len(DATA.time),max_layers), np.nan) _LAYER_POROSITY = np.full((len(DATA.time),max_layers), np.nan) _LAYER_ICE_FRACTION = np.full((len(DATA.time),max_layers), np.nan) _LAYER_IRREDUCIBLE_WATER = np.full((len(DATA.time),max_layers), np.nan) _LAYER_REFREEZE = np.full((len(DATA.time),max_layers), np.nan) # Start logging logger = logging.getLogger(__name__) #-------------------------------------------- # Initialize snowpack or load restart grid #-------------------------------------------- if GRID_RESTART is None: GRID = init_snowpack(DATA) else: GRID = load_snowpack(GRID_RESTART) # Create the local output datasets logger.debug('Create local datasets') IO = IOClass(DATA) RESTART = IO.create_local_restart_dataset() # Merge grid layers, if necessary logger.debug('Create local datasets') # hours since the last snowfall (albedo module) hours_since_snowfall = 0 #-------------------------------------------- # Get data from file #-------------------------------------------- T2 = DATA.T2.values RH2 = DATA.RH2.values PRES = DATA.PRES.values G = DATA.G.values U2 = DATA.U2.values #-------------------------------------------- # Checks for optional input variables #-------------------------------------------- if ('SNOWFALL' in DATA) and ('RRR' in DATA): SNOWF = DATA.SNOWFALL.values * mult_factor_RRR RRR = DATA.RRR.values * mult_factor_RRR elif ('SNOWFALL' in DATA): SNOWF = DATA.SNOWFALL.values * mult_factor_RRR RRR = None RAIN = None else: SNOWF = None RRR = DATA.RRR.values * mult_factor_RRR # Use RRR rather than snowfall? if force_use_TP is True: SNOWF = None if ('LWin' in DATA) and ('N' in DATA): LWin = DATA.LWin.values N = DATA.N.values elif ('LWin' in DATA): LWin = DATA.LWin.values else: LWin = None N = DATA.N.values # Use N rather than LWin if force_use_N is True: LWin = None if ('SLOPE' in DATA): SLOPE = DATA.SLOPE.values else: SLOPE = 0.0 # Initial cumulative mass balance variable MB_cum = 0 if stake_evaluation is True: # Create pandas dataframe for stake evaluation _df = pd.DataFrame(index=stake_data.index, columns=['mb','snowheight'], dtype='float') # Profiling with bokeh cp = cProfile.Profile() #-------------------------------------------- # TIME LOOP #-------------------------------------------- logger.debug('Start time loop') for t in np.arange(len(DATA.time)): # Check grid GRID.grid_check() # get seconds since start timestamp = dt*t # Calc fresh snow density density_fresh_snow = np.maximum(109.0+6.0*(T2[t]-273.16)+26.0*np.sqrt(U2[t]), 50.0) # Derive snowfall [m] and rain rates [m w.e.] if (SNOWF is not None) and (RRR is not None): SNOWFALL = SNOWF[t] RAIN = RRR[t]-SNOWFALL*(density_fresh_snow/ice_density) * 1000.0 elif (SNOWF is not None): SNOWFALL = SNOWF[t] else: # Else convert total precipitation [mm] to snowheight [m]; liquid/solid fraction SNOWFALL = (RRR[t]/1000.0)*(ice_density/density_fresh_snow)*(0.5*(-np.tanh(((T2[t]-zero_temperature) - center_snow_transfer_function) * spread_snow_transfer_function) + 1.0)) RAIN = RRR[t]-SNOWFALL*(density_fresh_snow/ice_density) * 1000.0 # if snowfall is smaller than the threshold if SNOWFALL<minimum_snow_layer_height: SNOWFALL = 0.0 # if rainfall is smaller than the threshold if RAIN<(minimum_snow_layer_height*(density_fresh_snow/ice_density)*1000.0): RAIN = 0.0 if SNOWFALL > 0.0: # Add a new snow node on top GRID.add_fresh_snow(SNOWFALL, density_fresh_snow, np.minimum(float(T2[t]),zero_temperature), 0.0, timestamp) # Guarantee that solar radiation is greater equal zero if (G[t]<0.0): G[t] = 0.0 #-------------------------------------------- # Merge grid layers, if necessary #-------------------------------------------- GRID.update_grid() #-------------------------------------------- # Calculate albedo and roughness length changes if first layer is snow #-------------------------------------------- alpha = updateAlbedo(GRID, timestamp) #-------------------------------------------- # Update roughness length #-------------------------------------------- z0 = updateRoughness(GRID, timestamp) #-------------------------------------------- # Surface Energy Balance #-------------------------------------------- # Calculate net shortwave radiation SWnet = G[t] * (1 - alpha) # Penetrating SW radiation and subsurface melt if SWnet > 0.0: subsurface_melt, G_penetrating = penetrating_radiation(GRID, SWnet, dt) else: subsurface_melt = 0.0 G_penetrating = 0.0 # Calculate residual incoming shortwave radiation (penetrating part removed) G_resid = G[t] - G_penetrating if LWin is not None: # Find new surface temperature (LW is used from the input file) fun, surface_temperature, lw_radiation_in, lw_radiation_out, sensible_heat_flux, latent_heat_flux, \ ground_heat_flux, sw_radiation_net, rho, Lv, Cs_t, Cs_q, q0, q2, phi \ = update_surface_temperature(GRID, alpha, z0, T2[t], RH2[t], PRES[t], G_resid, U2[t], SLOPE, LWin=LWin[t]) else: # Find new surface temperature (LW is parametrized using cloud fraction) fun, surface_temperature, lw_radiation_in, lw_radiation_out, sensible_heat_flux, latent_heat_flux, \ ground_heat_flux, sw_radiation_net, rho, Lv, Cs_t, Cs_q, q0, q2, phi \ = update_surface_temperature(GRID, alpha, z0, T2[t], RH2[t], PRES[t], G_resid, U2[t], SLOPE, N=N[t]) #-------------------------------------------- # Surface mass fluxes [m w.e.q.] #-------------------------------------------- if surface_temperature < zero_temperature: sublimation = min(latent_heat_flux / (water_density * lat_heat_sublimation), 0) * dt deposition = max(latent_heat_flux / (water_density * lat_heat_sublimation), 0) * dt evaporation = 0 condensation = 0 else: sublimation = 0 deposition = 0 evaporation = min(latent_heat_flux / (water_density * lat_heat_vaporize), 0) * dt condensation = max(latent_heat_flux / (water_density * lat_heat_vaporize), 0) * dt #-------------------------------------------- # Melt process - mass changes of snowpack (melting, sublimation, deposition, evaporation, condensation) #-------------------------------------------- # Melt energy in [W m^-2 or J s^-1 m^-2] melt_energy = max(0, sw_radiation_net + lw_radiation_in + lw_radiation_out + ground_heat_flux + sensible_heat_flux + latent_heat_flux) # Convert melt energy to m w.e.q. melt = melt_energy * dt / (water_density * lat_heat_melting) # Remove melt [m w.e.q.] GRID.remove_melt_weq(melt - sublimation - deposition - evaporation) #-------------------------------------------- # Percolation #-------------------------------------------- Q = percolation(GRID, melt - condensation, dt) #-------------------------------------------- # Refreezing #-------------------------------------------- water_refreezed = refreezing(GRID) #-------------------------------------------- # Solve the heat equation #-------------------------------------------- solveHeatEquation(GRID, dt) #-------------------------------------------- # Calculate new density to densification #-------------------------------------------- densification(GRID,SLOPE) #-------------------------------------------- # Calculate mass balance #-------------------------------------------- surface_mass_balance = SNOWFALL * (density_fresh_snow / ice_density) - melt - sublimation - deposition - evaporation internal_mass_balance = water_refreezed - subsurface_melt mass_balance = surface_mass_balance + internal_mass_balance internal_mass_balance2 = melt-Q #+ subsurface_melt mass_balance_check = surface_mass_balance + internal_mass_balance2 #GRID.grid_check() # Write results logger.debug('Write data into local result structure') # TOBI # Cumulative mass balance for stake evaluation MB_cum = MB_cum + mass_balance # Store cumulative MB in pandas frame for validation if stake_names: if (DATA.isel(time=t).time.values in stake_data.index): _df['mb'].loc[DATA.isel(time=t).time.values] = MB_cum _df['snowheight'].loc[DATA.isel(time=t).time.values] = GRID.get_total_snowheight() # Save results _RAIN[t] = RAIN _SNOWFALL[t] = SNOWFALL _LWin[t] = lw_radiation_in _LWout[t] = lw_radiation_out _H[t] = sensible_heat_flux _LE[t] = latent_heat_flux _B[t] = ground_heat_flux _MB[t] = mass_balance _surfMB[t] = surface_mass_balance _Q[t] = Q _SNOWHEIGHT[t] = GRID.get_total_snowheight() _TOTALHEIGHT[t] = GRID.get_total_height() _TS[t] = surface_temperature _ALBEDO[t] = alpha _NLAYERS[t] = GRID.get_number_layers() _ME[t] = melt_energy _intMB[t] = internal_mass_balance _EVAPORATION[t] = evaporation _SUBLIMATION[t] = sublimation _CONDENSATION[t] = condensation _DEPOSITION[t] = deposition _REFREEZE[t] = water_refreezed _subM[t] = subsurface_melt _Z0[t] = z0 _surfM[t] = melt if full_field: if GRID.get_number_layers()>max_layers: logger.error('Maximum number of layers reached') else: _LAYER_HEIGHT[t, 0:GRID.get_number_layers()] = GRID.get_height() _LAYER_RHO[t, 0:GRID.get_number_layers()] = GRID.get_density() _LAYER_T[t, 0:GRID.get_number_layers()] = GRID.get_temperature() _LAYER_LWC[t, 0:GRID.get_number_layers()] = GRID.get_liquid_water_content() _LAYER_CC[t, 0:GRID.get_number_layers()] = GRID.get_cold_content() _LAYER_POROSITY[t, 0:GRID.get_number_layers()] = GRID.get_porosity() _LAYER_ICE_FRACTION[t, 0:GRID.get_number_layers()] = GRID.get_ice_fraction() _LAYER_IRREDUCIBLE_WATER[t, 0:GRID.get_number_layers()] = GRID.get_irreducible_water_content() _LAYER_REFREEZE[t, 0:GRID.get_number_layers()] = GRID.get_refreeze() else: _LAYER_HEIGHT = None _LAYER_RHO = None _LAYER_T = None _LAYER_LWC = None _LAYER_CC = None _LAYER_POROSITY = None _LAYER_ICE_FRACTION = None _LAYER_IRREDUCIBLE_WATER = None _LAYER_REFREEZE = None if stake_evaluation is True: # Evaluate stakes _stat = evaluate(stake_names, stake_data, _df) else: _stat = None _df = None # Restart logger.debug('Write restart data into local restart structure') RESTART['NLAYERS'] = GRID.get_number_layers() RESTART.LAYER_HEIGHT[0:GRID.get_number_layers()] = GRID.get_height() RESTART.LAYER_RHO[0:GRID.get_number_layers()] = GRID.get_density() RESTART.LAYER_T[0:GRID.get_number_layers()] = GRID.get_temperature() RESTART.LAYER_LWC[0:GRID.get_number_layers()] = GRID.get_liquid_water_content() return (indY,indX,RESTART,_RAIN,_SNOWFALL,_LWin,_LWout,_H,_LE,_B, \ _MB,_surfMB,_Q,_SNOWHEIGHT,_TOTALHEIGHT,_TS,_ALBEDO,_NLAYERS, \ _ME,_intMB,_EVAPORATION,_SUBLIMATION,_CONDENSATION,_DEPOSITION,_REFREEZE, \ _subM,_Z0,_surfM, \ _LAYER_HEIGHT,_LAYER_RHO,_LAYER_T,_LAYER_LWC,_LAYER_CC,_LAYER_POROSITY,_LAYER_ICE_FRACTION, \ _LAYER_IRREDUCIBLE_WATER,_LAYER_REFREEZE,stake_names,_stat,_df)