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"])
