def set_parameters( self, tr_soil_out, V0_soil, beta_soil_out, ETV1, fETV0, meltrate, snow_melt_temp, ): """ Creates all connections with the parameter values produced by the sampling algorithm. """ # Get all definition from the init method p = self.project c = p[0] outlet = self.outlet soil = c.layers[0] # Adjustment of the ET c.set_uptakestress(cmf.VolumeStress(ETV1, ETV1 * fETV0)) # Flux from soil to outlet cmf.kinematic_wave(soil, outlet, tr_soil_out / V0_soil, V0=V0_soil, exponent=beta_soil_out) # # Set parameters of the snow calculations cmf.Weather.set_snow_threshold(snow_melt_temp) cmf.SimpleTindexSnowMelt(c.snow, soil, c, rate=meltrate)
def setparameters(self, tr, Vr=0.0, V0=1000., beta=1.0, ETV1=500., fETV0=0.0, initVol=100.): """ Setzt die Parameter, dabei werden parametrisierte Verbindungen neu erstellt MP111 - Änderungsbedarf: Sehr groß, hier werden alle Parameter des Modells gesetzt Verständlichkeit: mittel """ # Ein paar Abkürzungen um Tipparbeit zu sparen c = self.project[0] outlet = self.outlet # Setze den Water-Uptakestress c.set_uptakestress(cmf.VolumeStress(ETV1, ETV1 * fETV0)) cmf.kinematic_wave(c.layers[0], outlet, tr / V0, exponent=beta, residual=Vr, V0=V0) c.layers[0].volume = initVol
def create_connections(active_connections): """ Createas an kinematic wave conncetion and pulls the right parameters values from the param_dict :return: """ # Go through all active connections for connection in active_connections: temp, source_tr, target_tr = connection.split("_") # Save the parameter values to be able to create the connection connection_params = { "tr": param_dict[connection], # Include the default values for beta and # V0, so a kinematic wave can always be # created. "beta": 1.0, "V0": 1.0 } # Find all other parameter which belong to that connection for param in param_dict.keys(): try: name, source_param, target_param = param.split("_") # Save the values if ((name == "beta" or name == "V0") and source_tr == source_param and target_tr == target_param): connection_params[name] = param_dict[param] except ValueError: # ValueError is raised because the not all genes can be # split in three parts. But as all genes that are of # interest now can be, the error can pass. pass # Create the connection cmf.kinematic_wave(storages[source_tr], storages[target_tr], param_dict[connection], V0=connection_params["V0"], exponent=connection_params["beta"])
def first_simple_model(): import cmf import datetime p = cmf.project() # Create W1 in project p W1 = p.NewStorage(name="W1",x=0,y=0,z=0) # Create W2 in project p without any volume as an initial state W2 = p.NewStorage(name="W2",x=10,y=0,z=0) # Create a linear storage equation from W1 to W2 with a residence time tr of one day q = cmf.kinematic_wave(source=W1,target=W2,residencetime=1.0) # Set the initial state of w1 to 1m³ of water. W1.volume = 1.0 # Create Outlet Out = p.NewOutlet(name="Outlet",x=20,y=0,z=0) qout = cmf.kinematic_wave(source=W2,target=Out,residencetime=2.0) # Create a Neumann Boundary condition connected to W1 In = cmf.NeumannBoundary.create(W1) # Create a timeseries with daily alternating values. In.flux = cmf.timeseries(begin = datetime.datetime(2012,1,1), step = datetime.timedelta(days=1), interpolationmethod = 0) for i in range(10): # Add 0.0 m3/day for even days, and 1.0 m3/day for odd days In.flux.add(i % 2) # Create an integrator for the ODE represented by project p, with an error tolerance of 1e-9 solver = cmf.RKFIntegrator(p,1e-9) # Set the intitial time of the solver solver.t = datetime.datetime(2012,1,1) # Iterate the solver hourly through the time range and return for each time step the volume in W1 and W2 result = [[W1.volume,W2.volume] for t in solver.run(datetime.datetime(2012,1,1),datetime.datetime(2012,1,7),datetime.timedelta(hours=1))] import pylab as plt plt.plot(result) plt.xlabel('hours') plt.ylabel('Volume in $m^3$') plt.legend(('W1','W2')) plt.show()
def setparameters(self, tr_soil_GW = 12.36870481, tr_soil_fulda = 12., tr_surf = 3.560855356, tr_GW_l = 829.7188064, tr_GW_u_fulda = 270.05035, tr_GW_u_GW_l = 270., tr_fulda = 2.264612944, V0_soil = 280.0850875, beta_soil_GW=1.158865311, beta_fulda = 1.1, ETV1=2.575261852, fETV0=0.014808919, meltrate = 4.464735097, snow_melt_temp = 4.51938545, # Qd_max = 0.250552812, # TW_threshold = 10., LAI = 2.992013336, CanopyClosure = 5., Ksat = 0.02 ): # this list has to be identical with the one above """ sets the parameters, all parameterized connections will be created anew """ # Get all definitions from init method p = self.project c = p[0] outlet = self.outlet fulda = self.fulda # trinkwasser = self.trinkwasser # Adjustment of the evapotranspiration c.set_uptakestress(cmf.VolumeStress(ETV1,ETV1 * fETV0)) # Flux from the surfaces to the river cmf.kinematic_wave(c.surfacewater,fulda,tr_surf) # flux from surfaces to the soil (infiltration) cmf.SimpleInfiltration(c.layers[0], c.surfacewater) # change the saturated conductivity of the soil c.layers[0].soil.Ksat = Ksat # Flux from soil to river (interflow) cmf.kinematic_wave(c.layers[0],fulda,tr_soil_fulda/V0_soil, V0 = V0_soil) # flux from the soil to the upper groundwater (percolation) cmf.kinematic_wave(c.layers[0], c.layers[1],tr_soil_GW, exponent=beta_soil_GW) # flux from the upper groundwater to the river (baseflow) cmf.kinematic_wave(c.layers[1], fulda, tr_GW_u_fulda) # flux from upper to lower groundwater (percolation) cmf.kinematic_wave(c.layers[1], c.layers[2],tr_GW_u_GW_l)#, exponent=beta_GW_u_GW_l) # flux from the lower groundwater to river (baseflow) cmf.kinematic_wave(c.layers[2], fulda, tr_GW_l) # Flux from the lower groundwater to the drinking water outlet # the fourths argument is the amount that is now allowed to be slurped # # out of the lower groundwater # cmf.TechnicalFlux(c.layers[2],trinkwasser,Qd_max,TW_threshold,cmf.day) # # # Flux from drinking water to the river # cmf.waterbalance_connection(trinkwasser, fulda) # flux from the river to the outlet cmf.kinematic_wave(fulda, outlet, tr_fulda, exponent = beta_fulda) # set snowmelt temperature cmf.Weather.set_snow_threshold(snow_melt_temp) # Snowmelt at the surfaces snowmelt_surf = cmf.SimpleTindexSnowMelt(c.snow,c.surfacewater,c,rate=meltrate) # Splits the rainfall in interzeption and throughfall cmf.Rainfall(c.canopy,c, False, True) cmf.Rainfall(c.surfacewater,c, True, False) # Makes a overflow for the interception storage cmf.RutterInterception(c.canopy,c.surfacewater,c) # Transpiration on the plants is added cmf.CanopyStorageEvaporation(c.canopy,c.evaporation,c) # Sets the parameters for the interception c.vegetation.LAI= LAI # Defines how much throughfall there is (in %) c.vegetation.CanopyClosure = CanopyClosure
def set_parameters(self, params): """ Sets the parameters for the current cell. :param: params: dictionary of parameters. :return: """ # Get all definition from the init method cell = self.cell outlet = self.outlet soil = cell.layers[0] gw = cell.layers[1] # EVT1 must be adjusted to cell size ETV1 = params["ETV1"] ETV1 = (ETV1 / 1000) * cell.area # V0 must be adjusted to cell size as well V0_soil = params["V0_soil"] V0_soil = (V0_soil / 1000) * cell.area # Adjustment of the ET cell.set_uptakestress(cmf.VolumeStress( ETV1, ETV1 * params["fETV0"])) # Flux from soil to outlet cmf.kinematic_wave(soil, outlet, params["tr_soil_out"] / V0_soil, V0=V0_soil, exponent=params["beta_soil_out"]) # Flux from soil to groundwater cmf.kinematic_wave(soil, gw, params["tr_soil_gw"] / V0_soil, V0=V0_soil, exponent=params["beta_soil_gw"]) # Flux from the groundwater to the outlet (baseflow) cmf.kinematic_wave(gw, outlet, params["tr_gw_out"]) # Split the rainfall in interception and throughfall cmf.Rainfall(cell.canopy, cell, False, True) cmf.Rainfall(cell.surfacewater, cell, True, False) # Make an overflow for the interception storage cmf.RutterInterception(cell.canopy, cell.surfacewater, cell) # Transpiration from the plants is added cmf.CanopyStorageEvaporation(cell.canopy, cell.evaporation, cell) # Sets the paramaters for interception cell.vegetation.LAI = params["LAI"] # Defines how much throughfall there is (in %) cell.vegetation.CanopyClosure = params["CanopyClosure"] # # Set parameters of the snow calculations cmf.Weather.set_snow_threshold(params["snow_melt_temp"]) cmf.SimpleTindexSnowMelt(cell.snow, soil, cell, rate=params["meltrate"])
to import this file to the file of your own model using 'import' """ # make a simple cmf model with a surfacewater, soil and an outlet import numpy as np import cmf import datetime p = cmf.project() c = p.NewCell(0, 0, 0, 1000) # create the storages/outlet c.surfacewater_as_storage() c.add_layer(5.0) outlet = p.NewOutlet("outlet", 10, 0, 0) # add the connections between the storages cmf.kinematic_wave(c.surfacewater, outlet, 1) cmf.kinematic_wave(c.surfacewater, c.layers[0], 1) cmf.kinematic_wave(c.layers[0], outlet, 3) # create artificial rain data begin = datetime.datetime(1979, 1, 1) end = begin + 15 * datetime.timedelta(days=1) step = datetime.timedelta(days=1) P = cmf.timeseries(begin, step) P.extend(prec for prec in np.random.randint(0, high=30, size=15)) # add a rainstation rainstation = p.rainfall_stations.add("Rain", P, (0, 0, 0)) p.use_nearest_rainfall()
# -*- coding: utf-8 -*- """ Created on Mon Dec 09 09:50:35 2013 @author: kraft-p """ import cmf import datetime p = cmf.project() W1=p.NewStorage(name="W1",x=0,y=0,z=0) W2=p.NewStorage(name="W2",x=10,y=0,z=0) q = cmf.kinematic_wave(source=W1,target=W2,residencetime=5.0) W1.volume=1.0 Out = p.NewOutlet(name="Outlet",x=20,y=0,z=0) q2 = cmf.kinematic_wave(source=W1,target=Out,residencetime=1.0) qout = cmf.kinematic_wave(source=W2,target=Out,residencetime=.5) # Create a Neumann Boundary condition connected to W1 In = p.NewNeumannBoundary('In', W1) # Create a timeseries with daily alternating values. In.flux = cmf.timeseries(begin = datetime.datetime(2012,1,1), step = datetime.timedelta(days=1), interpolationmethod = 0) for i in range(1000): # Add 0.0 m3/day for even days, and 1.0 m3/day for odd days In.flux.add(i % 2) # Create the solver solver = cmf.ImplicitEuler(p,1e-9) import datetime # Iterate the solver hourly through the time range and return for each time step the volume in W1 and W2 result = [[W1.volume,W2.volume] for t in solver.run(datetime.datetime(2012,1,1),datetime.datetime(2012,2,1),datetime.timedelta(hours=1))]
def set_parameters( self, tr_soil_gw, tr_soil_out, tr_gw_out, V0_soil, beta_soil_gw, beta_soil_out, ETV1, fETV0, # # meltrate, # snow_melt_temp, LAI, CanopyClosure, ): """ Creates all connections with the parameter values produced by the sampling algorithm. """ print("tr_soil_gw: {}; tr_soil_out: {}; tr_gw_out: {}; V0_soil: {}; " "beta_soil_gw: {}; beta_soil_out: {}; ETV1: {}; fETV0: {}; " "LAI: {}; CanopyClosure:" " {}\n".format(tr_soil_gw, tr_soil_out, tr_gw_out, V0_soil, beta_soil_gw, beta_soil_out, ETV1, fETV0, LAI, CanopyClosure)) # Get all definition from the init method p = self.project c = p[0] outlet = self.outlet soil = c.layers[0] gw = c.layers[1] # Adjustment of the ET c.set_uptakestress(cmf.VolumeStress(ETV1, ETV1 * fETV0)) # Flux from soil to outlet cmf.kinematic_wave(soil, outlet, tr_soil_out / V0_soil, V0=V0_soil, exponent=beta_soil_out) # Flux from soil to groundwater cmf.kinematic_wave(soil, gw, tr_soil_gw / V0_soil, V0=V0_soil, exponent=beta_soil_gw) # Flux from the groundwater to the outlet (baseflow) cmf.kinematic_wave(gw, outlet, tr_gw_out) # Split the rainfall in interception and throughfall cmf.Rainfall(c.canopy, c, False, True) cmf.Rainfall(c.surfacewater, c, True, False) # Make an overflow for the interception storage cmf.RutterInterception(c.canopy, c.surfacewater, c) # Transpiration from the plants is added cmf.CanopyStorageEvaporation(c.canopy, c.evaporation, c) # Sets the paramaters for interception c.vegetation.LAI = LAI # Defines how much throughfall there is (in %) c.vegetation.CanopyClosure = CanopyClosure
# -*- coding: utf-8 -*- """ Created on Tue May 2 12:33:44 2017 @author: gh1961 """ #%% import cmf p = cmf.project('X Y') X, Y = p.solutes # Create W1 in project p W1 = p.NewStorage(name="W1", x=0, y=0, z=0) # Create W2 in project p without any volume as an initial state W2 = p.NewStorage(name="W2", x=10, y=0, z=0) # Create a linear storage equation from W1 to W2 with a residence time tr of one day q = cmf.kinematic_wave(source=W1, target=W2, residencetime=1.0) # Set the initial state of w1 to 1m³ of water. q.set_tracer_filter(X, 0.5) q.set_tracer_filter(Y, 0.25) #%% W1.volume = 1.0 W1.conc(X, 1.0) W1.conc(Y, 1.0) W2.volume = 0.0 W2.Solute(X).state = 0.0 W2.Solute(Y).state = 0.0 # Create an integrator for the ODE represented by project p, with an error tolerance of 1e-9 solver = cmf.RKFIntegrator(p, 1e-9) # Import Python's datetime module import datetime # Set the intitial time of the solver
def setparameters(self, tr_first_out, tr_first_river, tr_first_second, tr_second_third, tr_second_river, tr_third_river, tr_river_out, beta_first_out, beta_first_river, beta_first_second, beta_second_river, beta_second_third, beta_third_river, beta_river_out, canopy_lai, canopy_closure, snow_meltrate, snow_melt_temp, V0_first_out, V0_first_river, V0_first_second, ETV0, fETV0): """ sets the Parameters, all Parametrized connections will be created anew """ # Get all definitions from init method p = self.project cell = p[0] first = cell.layers[0] second = cell.layers[1] third = cell.layers[2] river = self.river out = self.outlet # Adjustment of the evapotranspiration cell.set_uptakestress(cmf.VolumeStress(ETV0, ETV0 * fETV0)) # Kinematic waves cmf.kinematic_wave(first, second, tr_first_second, exponent=beta_first_second, V0=V0_first_second) cmf.kinematic_wave(first, out, tr_first_out, exponent=beta_first_out, V0=V0_first_out) cmf.kinematic_wave(first, river, tr_first_river, exponent=beta_first_river, V0=V0_first_river) cmf.kinematic_wave(second, river, tr_second_river, exponent=beta_second_river) cmf.kinematic_wave(second, third, tr_second_third, exponent=beta_second_third) cmf.kinematic_wave(third, river, tr_third_river, exponent=beta_third_river) cmf.kinematic_wave(river, out, tr_river_out, exponent=beta_river_out) # set snowmelt temperature cmf.Weather.set_snow_threshold(snow_melt_temp) # Snowmelt at the surfaces cmf.SimpleTindexSnowMelt(cell.snow, cell.surfacewater, cell, rate=snow_meltrate) # Splits the rainfall in interception and throughfall cmf.Rainfall(cell.canopy, cell, False, True) cmf.Rainfall(cell.surfacewater, cell, True, False) # Makes a overflow for the interception storage cmf.RutterInterception(cell.canopy, cell.surfacewater, cell) # Transpiration on the plants is added cmf.CanopyStorageEvaporation(cell.canopy, cell.evaporation, cell) # Sets the Parameters for the interception cell.vegetation.LAI = canopy_lai # Defines how much throughfall there is (in %) cell.vegetation.CanopyClosure = canopy_closure
ws.Solute(X).set_adsorption(cmf.LinearAdsorption(1,1)) # Tracer Y has a Freundlich isotherm xa/m=Kc^n, # with K = 1 and n=0.5 and sorbent mass m = 1 ws.Solute(Y).set_adsorption(cmf.FreundlichAdsorbtion(1.,1.,1.0)) # Tracer Y has a Langmuir isotherm xa/m=Kc/(1+Kc), # with K = 1 and sorbent mass m = 1 ws.Solute(Z).set_adsorption(cmf.LangmuirAdsorption(1.,1.)) # Now we put a constant clean water flux into the storage inflow=cmf.NeumannBoundary.create(ws) inflow.flux = 1.0 # 1 m3/day for s in p.solutes: inflow.concentration[s] = 0.0 # And an outlet, a linear storage term with a retention time of 1 day outlet = p.NewOutlet('out',0,0,0) cmf.kinematic_wave(ws,outlet,1.) # Create a solver solver = cmf.ExplicitEuler_fixed(p) # Rinse the storage for 1 week and get the outlet concentration at every hour # and the remaining tracer in the storage result = [ [outlet.conc(t,s) for s in p.solutes] + [ws.Solute(s).state for s in p.solutes] for t in solver.run(solver.t,2*cmf.week,cmf.h) ] # Plot result ] from pylab import * result= array(result) conc=result[:,:len(p.solutes)] load = result[:,len(p.solutes):]
def setparameters(self, tr_soil_GW = 12.36870481, tr_soil_fulda = 12., # tr_surf = 3.560855356, tr_GW_l = 829.7188064, tr_GW_u_fulda = 270.05035, tr_GW_u_GW_l = 270., tr_fulda = 2.264612944, V0_soil = 280.0850875, beta_soil_GW=1.158865311, beta_fulda = 1.1, ETV1=2.575261852, fETV0=0.014808919, # meltrate = 4.464735097, # snow_melt_temp = 4.51938545, Qd_max = 0.250552812, TW_threshold = 10., # LAI = 2.992013336, # CanopyClosure = 5., # Ksat = 0.02 ): # this list has to be identical with the one above """ sets the parameters, all parameterized connections will be created anew """ # Get all definitions from init method p = self.project c = p[0] outlet = self.outlet fulda = self.fulda trinkwasser = self.trinkwasser # Adjustment of the evapotranspiration c.set_uptakestress(cmf.VolumeStress(ETV1,ETV1 * fETV0)) # Flux from the surfaces to the river # cmf.kinematic_wave(c.surfacewater,fulda,tr_surf) # flux from surfaces to the soil (infiltration) # cmf.SimpleInfiltration(c.layers[0], c.surfacewater) # change the saturated conductivity of the soil # c.layers[0].soil.Ksat = Ksat # Flux from soil to river (interflow) cmf.kinematic_wave(c.layers[0],fulda,tr_soil_fulda/V0_soil, V0 = V0_soil) # flux from the soil to the upper groundwater (percolation) cmf.kinematic_wave(c.layers[0], c.layers[1],tr_soil_GW, exponent=beta_soil_GW) # flux from the upper groundwater to the river (baseflow) cmf.kinematic_wave(c.layers[1], fulda, tr_GW_u_fulda) # flux from upper to lower groundwater (percolation) cmf.kinematic_wave(c.layers[1], c.layers[2],tr_GW_u_GW_l)#, exponent=beta_GW_u_GW_l) # flux from the lower groundwater to river (baseflow) cmf.kinematic_wave(c.layers[2], fulda, tr_GW_l) # Flux from the lower groundwater to the drinking water outlet # the fourths argument is the amount that is now allowed to be slurped # out of the lower groundwater cmf.TechnicalFlux(c.layers[2],trinkwasser,Qd_max,TW_threshold,cmf.day) # Flux from drinking water to the river cmf.waterbalance_connection(trinkwasser, fulda) # flux from the river to the outlet cmf.kinematic_wave(fulda, outlet, tr_fulda, exponent = beta_fulda)
def setparameters(self, param_dict: dict): """ Creates all connections with the parameter values produced by the sampling algorithm. :param param_dict: Dictionary of all the parameters and their values. :return None """ cell = self.project[0] storages = self.storages # Find all active connections active_connections = [] for param in param_dict.keys(): if "tr_" in param: active_connections.append(param) # Go through all active connections for connection in active_connections: temp, source_tr, target_tr = connection.split("_") # Save the parameter values to be able to create the connection connection_params = {"tr": param_dict[connection], # Include the default values for beta and # V0, so a kinematic wave can always be # created. "beta": 1.0, "V0": 1.0} # Find all other parameter which belong to that connection for param in param_dict.keys(): try: name, source_param, target_param = param.split("_") # Save the values if ((name == "beta" or name == "V0") and source_tr == source_param and target_tr == target_param): connection_params[name] = param_dict[param] except ValueError: # ValueError is raised because the not all genes can be # split in three parts. But as all genes that are of # interest now can be, the error can pass. pass # Create the connection cmf.kinematic_wave(storages[source_tr], storages[target_tr], param_dict[connection], V0=connection_params["V0"], exponent=connection_params["beta"]) # Fill in the snow parameters when they exist. If not # leave them at CMFs default value. if "snow" in self.genes: cmf.SimpleTindexSnowMelt(cell.snow, cell.surfacewater, cell, rate=param_dict.get("snow_meltrate", 7)) cmf.Weather.set_snow_threshold(param_dict.get("snow_melt_temp", 0.5)) # Fill in the canopy parameters when they exist if "canopy" in self.genes: # Splits the rainfall in interception and throughfall cmf.Rainfall(cell.canopy, cell, False, True) cmf.Rainfall(cell.surfacewater, cell, True, False) # Makes a overflow for the interception storage cmf.RutterInterception(cell.canopy, cell.surfacewater, cell) # Transpiration on the plants is added cmf.CanopyStorageEvaporation(cell.canopy, cell.evaporation, cell) # Set LAI and Canopy Closure if they exist in the dict. If not # leave them at CMFs default value. cell.vegetation.LAI = param_dict.get("canopy_lai", 2.88) cell.vegetation.CanopyClosure = param_dict.get("canopy_closure", 1.0) # Establish a waterbalance_connection if the river does not exist as # a separate storage, so the model treats it as if it would not exist. if "river" not in self.genes: cmf.waterbalance_connection(self.storages["river"], self.storages["out"])