def __init__(self, par):
cmf.set_parallel_threads(1)
# run the model
self.project = cmf.project()
self.cell = self.project.NewCell(x=0, y=0, z=238.628, area=1000, with_surfacewater=True)
c = self.cell
r_curve = cmf.VanGenuchtenMualem(Ksat=10**par.pKsat, phi=par.porosity, alpha=par.alpha, n=par.n)
# Make the layer boundaries and create soil layers
lthickness = [.01] * 5 + [0.025] * 6 + [0.05] * 6 + [0.1] * 5
ldepth = np.cumsum(lthickness)
# Create soil layers and pick the new soil layers if they are inside of the evaluation depth's
for d in ldepth:
c.add_layer(d, r_curve)
# Use a Richards model
c.install_connection(cmf.Richards)
# Use shuttleworth wallace
self.ET = c.install_connection(cmf.ShuttleworthWallace)
c.saturated_depth = 0.5
self.gw = self.project.NewOutlet('groundwater', x=0, y=0, z=.9)
cmf.Richards(c.layers[-1], self.gw)
self.gw.potential = c.z - 0.5 #IMPORTANT
self.gw.is_source = True
self.gwhead = cmf.timeseries.from_scalar(c.z - 0.5)
self.solver = cmf.CVodeIntegrator(self.project, 1e-9)
def __init__(self, begin, end):
"""Initializes the model and build the core setup"""
# tr_soil_GW = Residence time of the water in the soil to the GW
self.params = [param("tr_soil_out", 0., 200.),
# tr_GW_out = Residence time in the groundwater to
# the outlet
param('V0_soil', 0., 300.),
# beta_soil_out = exponent that changes the form of the
# flux from the soil to the outlet
param("beta_soil_out", 0.3, 8.0),
# ETV1 = the Volume that defines that the evaporation
# is lowered because of not enough water in the soil
param('ETV1', 0., 300.),
# fETV0 = factor the ET is multiplied by, when water is
# low
param('fETV0', 0., 0.9),
# Rate of snow melt
param('meltrate', 0.01, 15.),
# Snow_melt_temp = Temperature at which the snow melts
# (needed because of averaged temp
param('snow_melt_temp', -3.0, 3.0)
]
self.begin = begin
self.end = end
# load the weather data and discharge data
prec, temp, temp_min, temp_max, Q, wind, sun, \
rel_hum= self.loadPETQ()
self.Q = Q
# use only one core (faster when model is small
cmf.set_parallel_threads(1)
# Generate a cmf project with one cell for a lumped model
self.project = cmf.project()
p = self.project
# Create a cell in the project
c = p.NewCell(0, 0, 0, 1000)
# Add snow storage
c.add_storage("Snow", "S")
cmf.Snowfall(c.snow, c)
# Add the soil and groundwater layers
soil = c.add_layer(2.0)
# Give the storages a initial volume
c.layers[0].volume = 15
# Install a calculation of the evaporation
cmf.PenmanMonteithET(soil, c.transpiration)
# Create an outlet
self.outlet = p.NewOutlet("outlet", 10, 0, 0)
# Create the meteo stations
self.make_stations(prec, temp, temp_min, temp_max, wind, sun,
rel_hum)
self.project = p
def __init__(self):
self.Params = [
Param("tr_first_out", 0., 300),
Param("tr_first_river", 0., 300),
Param("tr_first_second", 0., 300),
Param("tr_second_third", 0., 300),
Param("tr_second_river", 0., 300),
Param("tr_third_river", 0., 300),
Param("tr_river_out", 0., 300),
Param("beta_first_out", 0., 4),
Param("beta_first_river", 0., 4),
Param("beta_first_second", 0., 4),
Param("beta_second_river", 0., 4),
Param("beta_second_third", 0., 4),
Param("beta_third_river", 0., 4),
Param("beta_river_out", 0., 4),
Param("canopy_lai", 1., 10),
Param("canopy_closure", 0., 1.0),
Param("snow_meltrate", 0.1, 15.),
Param("snow_melt_temp", -5.0, 5.0),
Param("V0_first_out", 0., 200),
Param("V0_first_river", 0., 200),
Param("V0_first_second", 0., 200),
Param("ETV0", 0, 200),
Param("fETV0", 0., 0.85)
]
precipitation, temperature_avg, temperature_min, \
temperature_max, discharge = utils.load_data(
"observed_discharge.txt",
"temperature_max_min_avg.txt",
"precipitation.txt",
2976.41
)
self.Q = discharge
cmf.set_parallel_threads(1)
self.project = cmf.project()
project = self.project
cell = project.NewCell(0, 0, 0, 1000)
cell.add_storage("Snow", "S")
cmf.Snowfall(cell.snow, cell)
cell.add_layer(2.0)
cell.add_layer(5.0)
cell.add_layer(10.0)
cmf.HargreaveET(cell.layers[0], cell.transpiration)
self.outlet = project.NewOutlet("outlet", 10, 0, 0)
self.make_stations(precipitation, temperature_avg, temperature_min,
temperature_max)
self.river = cell.add_storage("River", "R")
self.canopy = cell.add_storage("Canopy", "C")
self.begin = datetime.datetime(1979, 1, 1)
self.end = datetime.datetime(1986, 12, 31)
def __init__(self, begin, end):
"""
Initialisiert das Modell und baut das Grundsetup zusammen
MP111 - Änderungsbedarf: Sehr groß, hier wird es Euer Modell definiert
Verständlichkeit: mittel
"""
# TODO: Parameterliste erweitern und anpassen.
# Wichtig: Die Namen müssen genau die gleichen sein,
# wie die Argumente in der Funktion setparameters.
#
# Parameter werden wie folgt definiert:
# param(<Name>,<Minimum>,<Maximum>)
self.params = [
param('tr', 0., 1000.),
param('ETV1', 0., 1000.),
param('Vr', 0., 1000.),
param('fETV0', 0., 1.),
param('beta', 0.3, 5.0)
]
# Lädt die Treiber Daten
P, T, Tmin, Tmax, Q = self.loadPETQ()
self.Q = Q
# Nutze nur einen Kern - für unser Modell ist das schneller
cmf.set_parallel_threads(1)
# Erzeuge ein Projekt mit einer Zelle für lumped Modell
self.project = cmf.project()
p = self.project
c = p.NewCell(0, 0, 0, 1000)
# Füge Speicher zur Zelle
l = c.add_layer(1.0)
# TODO: Weitere Layer / Speicher zur Zelle hinzufügen
# Verdunstung
cmf.HargreaveET(l, c.transpiration)
# Outlet
self.outlet = p.NewOutlet('outlet', 10, 0, 0)
# Regen
self.makestations(P, T, Tmin, Tmax)
self.project = p
self.begin = begin
self.end = end
def create_project(self):
"""
Creates and CMF project with an outlet and other basic stuff and
returns it.
:return: cmf project and cmf outlet
"""
# Use only a single thread, that is better for a calibration run and
# for small models
cmf.set_parallel_threads(1)
# make the project
p = cmf.project()
# make the outlet
outlet = p.NewOutlet("outlet", 10, 0, 0)
return p, outlet
def __init__(self, begin: datetime.datetime, end: datetime.datetime,
subcatchment_names):
"""
:param begin:
:param end:
"""
project = cmf.project()
# Add outlet
self.outlet = project.NewOutlet("Outlet", 50, 0, 0)
self.project = project
self.begin = begin
self.end = end
self.subcatchment_names = subcatchment_names
self.dis_eval, self.subcatchments = self.load_data()
self.params = self.create_params()
self.cell_list = self.create_cells()
cmf.set_parallel_threads(1)
def create_project(self):
"""
Creates the cmf project with its basic elements
"""
# Use only a single thread, that is better for a calibration run and for small models
cmf.set_parallel_threads(1)
# make the project
p = cmf.project()
# make a new cell
c = p.NewCell(0, 0, 0, 1000)
# Add a storage
layer = c.add_layer(1.0)
# ET
cmf.HargreaveET(layer, c.transpiration)
# Outlet
outlet = p.NewOutlet('outlet', 10, 0, 0)
return p, outlet
def basic_model_setup():
"""
Creates the basic layout needed for every model structure.
:return: None
"""
# Basic Layout, same for all possible models
prec = data["prec"]
obs_discharge = data["discharge"]
t_mean = data["t_mean"]
t_min = data["t_min"]
t_max = data["t_max"]
self.obs_discharge = obs_discharge
# Use only one core (quicker for smaller models)
cmf.set_parallel_threads(1)
# Generate a project with one cell for a lumped model
self.project = cmf.project()
project = self.project
# Add one cell, which will include all other parts. The area is set
# to 1000 m², so the units are easier to understand
cell = project.NewCell(0, 0, 0, 1000)
# Add a first layer, this one is always present, as a model with no
# layers makes no sense
first_layer = cell.add_layer(2.0)
# Add an evapotranspiration
cmf.HargreaveET(first_layer, cell.transpiration)
# Create the CMF meteo and rain stations
weather_stations.make_stations(self.project, prec, t_mean, t_min,
t_max)
# Create an outlet
self.outlet = project.NewOutlet("outlet", 10, 0, 0)
def __init__(self,datastart,dataend,analysestart):
self.datastart=datastart
self.dataend=dataend
self.analysestart=analysestart
self.bound= [[0.0001,0.6],[0.01,3],[1.05,1.4],[0.4,0.7]]
DataLoader = loader.load_data(analysestart,datastart,dataend)
cmf.set_parallel_threads(1)
###################### Forcing data ####################################
ClimateFilename = 'Climate_Face_new2.csv'
try:
self.meteoarray=np.load(ClimateFilename+str(datastart.date())+str(dataend.date())+'.npy')
self.rain = cmf.timeseries.from_array(begin = self.datastart, step = timedelta(hours=1), data=self.meteoarray['Nd_mm_day'])#in mm/day
self.rHmean = cmf.timeseries.from_array(begin = self.datastart, step = timedelta(hours=1), data=self.meteoarray['Rh'])
self.Windspeed = cmf.timeseries.from_array(begin = self.datastart, step = timedelta(hours=1), data=self.meteoarray['Wind'])
self.Rs = cmf.timeseries.from_array(begin = self.datastart, step = timedelta(hours=1), data=self.meteoarray['Rs_meas'])
self.T = cmf.timeseries.from_array(begin = self.datastart, step = timedelta(hours=1), data=self.meteoarray['Temp'])
except:
DataLoader.climate_pickle(ClimateFilename)
self.meteoarray=np.load(ClimateFilename+str(datastart.date())+str(dataend.date())+'.npy')
self.rain = cmf.timeseries.from_array(begin = self.datastart, step = timedelta(hours=1), data=self.meteoarray['Nd_mm_day'])#in mm/day
self.rHmean = cmf.timeseries.from_array(begin = self.datastart, step = timedelta(hours=1), data=self.meteoarray['Rh'])
self.Windspeed = cmf.timeseries.from_array(begin = self.datastart, step = timedelta(hours=1), data=self.meteoarray['Wind'])
self.Rs = cmf.timeseries.from_array(begin = self.datastart, step = timedelta(hours=1), data=self.meteoarray['Rs_meas'])
self.T = cmf.timeseries.from_array(begin = self.datastart, step = timedelta(hours=1), data=self.meteoarray['Temp'])
self.piezometer = 'P4'
self.gw_array = DataLoader.groundwater(self.piezometer)
###########################################################################
###################### Evaluation data ####################################
eval_soil_moisture = DataLoader.soil_moisture('A1')
self.eval_dates = eval_soil_moisture['Date']
self.observations = eval_soil_moisture['A1']
def __init__(self,begin,end, with_valid_data = False, shift_one_day = False):
"""
Initializes the model and builds the core setup
begin: begin of the calibration period
eng: end of the calibration period
with_calib_data: save also the data from the validation period
the calibration is still only done form 'begin' to 'end'
"""
# tr_S = Residence time of the water in the soil to the GW
self.params = [param('tr_soil_GW',0.5,150.),
# tr_soil_river = residence time from soil to river
param("tr_soil_fulda", 0.5,55.),
# tr_surf = Residence time from surface
param('tr_surf',0.001,30),
# tr_GW_l = residence time in the lower groundwate
param('tr_GW_l',1.,1000.),
# tr_GW_u = Residence time in the upper groundwater to the river
param('tr_GW_u_fulda',1.,750.),
# tr_GW_u_GW_l = residencete time to GW_l from GW_u
param("tr_GW_u_GW_l", 10., 750.),
# tr_fulda = Residence time in the river (in days)
param('tr_fulda', 0., 3.5),
# V0_soil = field capacity for the soil
param('V0_soil',15.,350.),
# beta_P_soil = Exponent that changes the form of the flux from the soil
param('beta_soil_GW',0.5,3.2),
# beta_fulda = exponent that changes the form of the flux from the soil
param("beta_fulda", 0.3,4.),
# ETV1 = the Volume that defines that the evaporation is lowered because of not enough water
param('ETV1',0.,100.),
# fETV0 = factor the ET is multiplied with when water is low
param('fETV0',0.,0.25),
# Rate of snow melt
param('meltrate',0.15,10.),
# Snow_melt_temp = Temperature at which the snow melts (needed because of averaged temp
param('snow_melt_temp',-1.0,4.2) ,
# #Qd_max = maximal flux from lower groundwater to drinking water production
# param('Qd_max', 0.,3.),
# # tw_thresholt = amount of water that can't be slurped out by the water pumps
# param("TW_threshold", 0.,100.),
# LAI = leaf area index
param('LAI', 1.,12.),
# Canopy Closure
param("CanopyClosure",0.,0.5),
# Ksat = saturated conductivity of the soil
param("Ksat", 0., 1)
]
# loads the data
P,T,Tmin,Tmax,Q = self.loadPETQ()
self.Q=Q
# only use one core (quicker for small models)
cmf.set_parallel_threads(1)
# Generate a project with on ecell for a lumped model
self.project = cmf.project()
p = self.project
# Add cell for soil and so on (x,y,z,area)
c = p.NewCell(0,0,0,1000)
# Add snow storage
c.add_storage('Snow','S')
cmf.Snowfall(c.snow,c)
# Surfacewater is treated as a storage
c.surfacewater_as_storage()
# Add the soil and groundwater layers to the soil cell
soil = c.add_layer(2.0)
gw_upper = c.add_layer(5.0)
gw_lower = c.add_layer(20.0)
# Fill storages
c.layers[0].volume = 15
c.layers[1].volume = 80
c.layers[2].volume = 120
# Evapotranspiration
cmf.HargreaveET(soil,c.transpiration)
#cmf.PenmanMonteith()
# Add the Fulda River
self.fulda = p.NewOpenStorage(name="Fulda",x=0,y=0,z=0, area = 3.3*10**6)
# Giving the Fulda a mean depth
self.fulda.potential = 1.5
# add the drinking water outlet
# self.trinkwasser = p.NewOutlet('trinkwasser',20,0,0)
# Outlet
self.outlet = p.NewOutlet('outlet',10,0,0)
# Storage for the interception
I=c.add_storage('Canopy','C')
# Rain
self.makestations(P,T,Tmin,Tmax)
self.project = p
self.begin = begin
self.end = end
self.with_valid_data = with_valid_data
self.shift_one_day = shift_one_day
def __init__(self, begin, end):
"""Initializes the model and build the core setup"""
# tr_soil_GW = Residence time of the water in the soil to the GW
self.params = [
spotpy.parameter.List("tr_soil_gw",
[361.95603672540824, 361.95603672540824]),
spotpy.parameter.List("tr_soil_out",
[86.36633856546166, 86.36633856546166]),
spotpy.parameter.List("tr_gw_out",
[81.8626412596028, 81.8626412596028]),
spotpy.parameter.List("V0_soil",
[291.9533350694828, 291.9533350694828]),
spotpy.parameter.List("beta_soil_gw",
[2.1866023626527475, 2.1866023626527475]),
spotpy.parameter.List("beta_soil_out", [0.2, 0.2]),
spotpy.parameter.List("ETV1",
[101.66837396299148, 101.66837396299148]),
spotpy.parameter.List("fETV0",
[0.4727208059864018, 0.4727208059864018]),
# spotpy.parameter.List("meltrate",
# [7.609473369272333,
# 7.609473369272333]),
# spotpy.parameter.List("snow_melt_temp",
# [2.887783422377442,
# 2.887783422377442]),
spotpy.parameter.List("LAI", [4.865867934808, 4.865867934808]),
spotpy.parameter.List("CanopyClosure",
[0.1924997461816065, 0.1924997461816065]),
]
self.begin = begin
self.end = end
# load the weather data and discharge data
prec, temp, temp_min, temp_max, Q, = self.loadPETQ()
self.Q = Q
# use only one core (faster when model is small
cmf.set_parallel_threads(1)
# Generate a cmf project with one cell for a lumped model
self.project = cmf.project()
p = self.project
# Create a cell in the projectl_evapotranspiration
c = p.NewCell(0, 0, 0, 1000, True)
# # Add snow storage
# c.add_storage("Snow", "S")
# cmf.Snowfall(c.snow, c)
# Add the soil and groundwater layers
soil = c.add_layer(2.0)
gw_upper = c.add_layer(5.0)
# Give the storages a initial volume
soil.volume = 15
gw_upper.volume = 80
# Create a storage for Interception
I = c.add_storage("Canopy", "C")
# Install a calculation of the evaporation
cmf.HargreaveET(soil, c.transpiration)
# Create an outlet
self.outlet = p.NewOutlet("outlet", 10, 0, 0)
# Create the meteo stations
self.make_stations(prec, temp, temp_min, temp_max)
self.project = p
wetness = numpy.array(wetness)
# Make a times/depth contour map
pylab.contourf([pylab.date2num(t.AsPython()) for t in outflow.iter_time()],
c.layers.thickness * 0.5 - c.layers.lower_boundary,
wetness.T,
levels=numpy.linspace(wetness.min(), 1, 50),
cmap=pylab.cm.jet_r,
extend='both',
)
pylab.title('Wetness')
pylab.gca().xaxis_date()
pylab.axis('tight')
pylab.show()
# If this file is started as a script and not imported as a library
if __name__ == '__main__':
# Run the model for 5 years
import time
tstart = time.time()
cmf.set_parallel_threads(1)
outflow, wetness = run(cmf.year * 5)
print('{:g} s, {} rhs evaluations'.format(
time.time() - tstart, solver.get_rhsevals()))
# print c.vegetation
# Try to plot the results
try:
plotresult(outflow, wetness)
except ImportError:
print("Matplotlib is not installed or has a failure. No plotting possible")
def __init__(self, begin, end):
"""Initializes the model and build the core setup"""
# tr_soil_GW = Residence time of the water in the soil to the GW
self.params = [
param('tr_soil_gw', 0., 400.),
# tr_soil_fulda = residence time from soil to river
param("tr_soil_out", 0., 200.),
# tr_gw_upper_fulda = residence time from the upper
# groundwater to the river
param("tr_gw_out", 0., 650.),
# V0_soil = field capacity for the soil
param('V0_soil', 0., 300.),
# beta_soil_GW = Changes the flux curve of the soil
# to the groundwater
param('beta_soil_gw', 0.3, 6.0),
# beta_soil_out
param("beta_soil_out", 0.3, 8.0),
# ETV1 = the Volume that defines that the evaporation
# is lowered because of not enough water in the soil
param('ETV1', 0., 300.),
# fETV0 = factor the ET is multiplied by, when water is
# low
param('fETV0', 0., 0.9),
# Rate of snow melt
param('meltrate', 0.01, 15.),
# Snow_melt_temp = Temperature at which the snow melts
# (needed because of averaged temp
param('snow_melt_temp', -3.0, 3.0),
# LAI = leaf area index
param('LAI', 1., 12),
# Canopy Closure
param("CanopyClosure", 0., 0.9),
]
self.begin = begin
self.end = end
# load the weather data and discharge data
prec, temp, temp_min, temp_max, Q, wind, sun, \
rel_hum = self.loadPETQ()
self.Q = Q
# use only one core (faster when model is small
cmf.set_parallel_threads(1)
# Generate a cmf project with one cell for a lumped model
self.project = cmf.project()
p = self.project
# Create a cell in the projectl_evapotranspiration
c = p.NewCell(0, 0, 0, 1000)
# Add snow storage
c.add_storage("Snow", "S")
cmf.Snowfall(c.snow, c)
# Add the soil and groundwater layers
soil = c.add_layer(2.0)
gw_upper = c.add_layer(5.0)
# Give the storages a initial volume
soil.volume = 15
gw_upper.volume = 80
# Create a storage for Interception
I = c.add_storage("Canopy", "C")
# Install a calculation of the evaporation
cmf.PenmanMonteithET(soil, c.transpiration)
# Create an outlet
self.outlet = p.NewOutlet("outlet", 10, 0, 0)
# Create the meteo stations
self.make_stations(prec, temp, temp_min, temp_max, wind, sun, rel_hum)
self.project = p
def __init__(self, datastart, dataend, analysestart):
self.datastart = datastart
self.dataend = dataend
self.analysestart = analysestart
self.bound = [[0.0001, 0.6], [0.01, 3], [1.05, 1.4], [0.4, 0.7]]
DataLoader = loader.load_data(analysestart, datastart, dataend)
cmf.set_parallel_threads(1)
###################### Forcing data ####################################
ClimateFilename = 'Climate_Face_new2.csv'
try:
self.meteoarray = np.load(ClimateFilename + str(datastart.date()) +
str(dataend.date()) + '.npy')
self.rain = cmf.timeseries.from_array(
begin=self.datastart,
step=timedelta(hours=1),
data=self.meteoarray['Nd_mm_day']) #in mm/day
self.rHmean = cmf.timeseries.from_array(begin=self.datastart,
step=timedelta(hours=1),
data=self.meteoarray['Rh'])
self.Windspeed = cmf.timeseries.from_array(
begin=self.datastart,
step=timedelta(hours=1),
data=self.meteoarray['Wind'])
self.Rs = cmf.timeseries.from_array(
begin=self.datastart,
step=timedelta(hours=1),
data=self.meteoarray['Rs_meas'])
self.T = cmf.timeseries.from_array(begin=self.datastart,
step=timedelta(hours=1),
data=self.meteoarray['Temp'])
except:
DataLoader.climate_pickle(ClimateFilename)
self.meteoarray = np.load(ClimateFilename + str(datastart.date()) +
str(dataend.date()) + '.npy')
self.rain = cmf.timeseries.from_array(
begin=self.datastart,
step=timedelta(hours=1),
data=self.meteoarray['Nd_mm_day']) #in mm/day
self.rHmean = cmf.timeseries.from_array(begin=self.datastart,
step=timedelta(hours=1),
data=self.meteoarray['Rh'])
self.Windspeed = cmf.timeseries.from_array(
begin=self.datastart,
step=timedelta(hours=1),
data=self.meteoarray['Wind'])
self.Rs = cmf.timeseries.from_array(
begin=self.datastart,
step=timedelta(hours=1),
data=self.meteoarray['Rs_meas'])
self.T = cmf.timeseries.from_array(begin=self.datastart,
step=timedelta(hours=1),
data=self.meteoarray['Temp'])
self.piezometer = 'P4'
self.gw_array = DataLoader.groundwater(self.piezometer)
###########################################################################
###################### Evaluation data ####################################
eval_soil_moisture = DataLoader.soil_moisture('A1')
self.eval_dates = eval_soil_moisture['Date']
self.observations = eval_soil_moisture['A1']
