LandscapeDNDC  1.36.0
ldndc::EcHy Class Reference

Watercycle model EcosystemHydrology - EcHy. More...

Inherits ldndc::MBE_LegacyModel.

Public Member Functions

lerr_t solve ()
 

Private Member Functions

lerr_t EcHyIrrigation ()
 Irrigation.
 
lerr_t EcHyFlood ()
 sets hydrologic conditions during flooding events, e.g., More...
 
lerr_t EcHyPercolation (size_t, size_t)
 Calculates water percolation within the soil profile.
 
lerr_t EcHyBypassFlow (double, double &)
 Calculates water percolation within the soil profile.
 
lerr_t EcHyEvapotranspiration ()
 Calculates evapotranspiration within the soil profile.
 
lerr_t EcHySubsl2 (double const &, double const &, int const &, double const &, double &)
 ... More...
 
lerr_t EcHyBalanceCheck (double &)
 ... More...
 
void EcHyreset ()
 ...
 
lerr_t EcHyGroundwater ()
 ... More...
 
lerr_t EcHyIntegration ()
 ... More...
 
lerr_t EcHyStepInit ()
 ...
 
lerr_t EcHyStepExit ()
 ...
 
double EcHyGetInterceptionCapacity ()
 ...
 
lerr_t EcHyCalculateLeafWaterDistribution (lvector_t< double > &)
 ...
 
lerr_t EcHyPotentialEvapotranspiration ()
 Calculates potential evapotranspiration. Specific concept can be given as model option.
 
lerr_t EcHySnowIce ()
 Calls SnowDNDC for the calculation of snowpack and soil ice formation.
 
double EcHyGetMinimumWater (size_t)
 ...
 
double EcHyGetWiltingPoint (size_t)
 ...
 
double EcHyGetAvailableWaterTranspiration (size_t)
 ...
 
double EcHyGetAvailableWaterEvaporation (size_t)
 ...
 
double EcHyGetRootLimitation (double)
 ...
 
double EcHyGetWaterLimitationTranspiration (double, size_t)
 ...
 
double EcHySoilWaterChange (size_t)
 

Private Attributes

double kst_bottom
 
double gw_depth_static
 
double accumulated_potentialtranspiration_old
 
double accumulated_irrigation_old
 
lvector_t< double > trwl_sl
 
lvector_t< double > wlfl_sl
 
lvector_t< double > cr_fill_sl
 
lvector_t< double > gw_fill_sl
 
lvector_t< double > bypass_fill_sl
 
lvector_t< double > wc_max_sl
 
lvector_t< double > wc_min_sl
 
lvector_t< double > evsws_sl
 
lvector_t< double > kst_sl
 
lvector_t< double > wl_sl
 
lvector_t< double > wlfc_sl
 
lvector_t< double > wlwp_sl
 
lvector_t< double > wlst_sl
 
double ev_leaf
 
double gw_fill_surface
 
double cr_fill_groundwater
 
double runoff
 
double snowfall
 
double throughfall
 
double interception_water
 
double thornthwaite_heat_index
 
double daily_potential_evapotranspiration
 
double daily_potential_leaf_evaporation
 
double daily_potential_soil_evaporation
 
double daily_potential_transpiration
 
WaterCycleSnowDNDC::IceContentStateIn m_icecontent_in
 
cbm::string_t evapotranspiration_method
 
cbm::string_t runoff_method
 

Detailed Description

Watercycle model EcosystemHydrology - EcHy.

Member Function Documentation

◆ EcHyBalanceCheck()

lerr_t ldndc::EcHy::EcHyBalanceCheck ( double &  _balance)
private

...

Checks balance between all incoming and outgoing water fluxes.

References cr_fill_groundwater, ev_leaf, evsws_sl, gw_fill_sl, gw_fill_surface, interception_water, runoff, snowfall, throughfall, trwl_sl, wl_sl, and wlfl_sl.

Referenced by solve().

455 {
456  double balance( interception_water + surface_water + surface_ice);
457  for ( size_t sl = 0; sl < soillayers_in->soil_layer_cnt(); ++sl)
458  {
459  balance += wl_sl[sl] + wc_.ice_sl[sl] * sc_.h_sl[sl];
460  }
461 
462  if ( _balance > 0.0)
463  {
464  balance += wlfl_sl[soillayers_in->soil_layer_cnt()]
465  + ev_leaf + evsws_sl.sum() + trwl_sl.sum() + runoff
467  - irrigation - throughfall - snowfall;
468 
469  double const balance_delta( std::abs( _balance - balance));
470  if ( cbm::flt_greater( balance_delta, 1.0e-4))
471  {
472  KLOGWARN( "Water leakage in: ", name(),
473  " Difference: ", balance - _balance);
474  return LDNDC_ERR_FAIL;
475  }
476  }
477  else
478  {
479  _balance = balance;
480  }
481 
482  return LDNDC_ERR_OK;
483 }
double gw_fill_surface
Definition: echy.h:128
double ev_leaf
Definition: echy.h:125
lvector_t< double > evsws_sl
Definition: echy.h:107
double cr_fill_groundwater
Definition: echy.h:131
double interception_water
Definition: echy.h:143
lvector_t< double > gw_fill_sl
Definition: echy.h:95
lvector_t< double > wl_sl
Definition: echy.h:113
double snowfall
Definition: echy.h:137
double runoff
Definition: echy.h:134
lvector_t< double > wlfl_sl
Definition: echy.h:89
double throughfall
Definition: echy.h:140
lvector_t< double > trwl_sl
Definition: echy.h:81
Here is the caller graph for this function:

◆ EcHyFlood()

lerr_t ldndc::EcHy::EcHyFlood ( )
private

sets hydrologic conditions during flooding events, e.g.,

Flooding.

  • surface water table
  • bund height

References kst_bottom, and kst_sl.

Referenced by solve().

18 {
19  lerr_t rc = m_eventflood.solve();
20  if ( rc != LDNDC_ERR_OK){ return rc; }
21 
22  bund_height = m_eventflood.get_bund_height();
23 
24  /* todo */
25  //irrigation_amount = m_eventflood.get_irrigation_amount();
26 
27  /* todo */
28  //double const irrigation_height = m_eventflood.get_irrigation_height();
29  double const max_percolation = m_eventflood.get_maximum_percolation();
30  double const water_table_flooding = m_eventflood.get_water_table();
31 
32 
33  irrigation_switch = NONE;
34  minimum_watertable_height = 0.0;
35  if ( cbm::is_valid( water_table_flooding))
36  {
37  if ( cbm::flt_greater_zero( water_table_flooding))
38  {
39  irrigation_switch = CONSTANT_POSITIVE_WATER_TABLE;
40  minimum_watertable_height = water_table_flooding;
41  bund_height = water_table_flooding;
42  }
43  else
44  {
45  irrigation_switch = CONSTANT_NEGATIVE_WATER_TABLE;
46  minimum_watertable_height = water_table_flooding;
47  bund_height = 0.0;
48  }
49  }
50 
51 
52  size_t sl_max( soillayers_in->soil_layer_cnt()-1);
53  if ( cbm::is_valid( max_percolation))
54  {
55  kst_sl[sl_max] = max_percolation / lclock()->time_resolution();
56  }
57  else
58  {
59  double const time_rate( 0.1 / lclock()->time_resolution());
60  kst_sl[sl_max] = cbm::bound_min( 0.0,
61  kst_sl[sl_max] - (kst_sl[sl_max] - kst_bottom) * time_rate);
62  }
63 
64  return LDNDC_ERR_OK;
65 }
lvector_t< double > kst_sl
Definition: echy.h:110
double kst_bottom
Definition: echy.h:67
Here is the caller graph for this function:

◆ EcHyGroundwater()

lerr_t ldndc::EcHy::EcHyGroundwater ( )
private

...

Negative groundwater table represents water on the soil surface

Negative groundwater table represents water on the soil surface

References cr_fill_groundwater, cr_fill_sl, EcHySoilWaterChange(), gw_depth_static, gw_fill_sl, gw_fill_surface, kst_sl, wc_max_sl, wc_min_sl, wl_sl, and wlst_sl.

Referenced by solve().

19 {
20  cbm::invalidate( kst_bottom_gw_vertical);
21  if ( cbm::flt_greater( sc_.depth_sl[soillayers_in->soil_layer_cnt()-1], gw_depth_static))
22  {
27  if ( cbm::flt_greater( -gw_depth_static, surface_water))
28  {
29  gw_fill_surface = -gw_depth_static - surface_water;
30  }
31 
32  //groundwater access
33  {
34  size_t sl( 0);
35  double const layer_midpoint_depth( 0.5 * sc_.h_sl[sl]);
36  if ( cbm::flt_greater_equal( layer_midpoint_depth, gw_depth_static))
37  {
38  gw_fill_sl[sl] = cbm::bound_min( 0.0,
39  wlst_sl[sl] - (wl_sl[sl] + EcHySoilWaterChange( sl)));
40  wc_.accumulated_groundwater_access += gw_fill_sl[sl];
41  }
42  else
43  {
44  double const wl_new( wl_sl[sl] + EcHySoilWaterChange( sl));
45  double const wc_new( cbm::bound( wc_min_sl[sl], wl_new / sc_.h_sl[sl], wc_max_sl[sl]));
46  kst_bottom_gw_vertical = cbm::bound_min( 0.0,
47  ldndc::hydrology::hydraulic_conductivity(
48  wc_new,
49  sc_.vgm_sl[sl],
50  wc_max_sl[sl],
51  wc_min_sl[sl],
52  kst_sl[sl]));
53  gw_fill_sl[sl] = 0.0;
54  }
55  }
56 
57  for (size_t sl = 1; sl < soillayers_in->soil_layer_cnt()-1; sl++)
58  {
59  double const layer_midpoint_depth( sc_.depth_sl[sl] - 0.5 * sc_.h_sl[sl]);
60  if ( cbm::flt_greater_equal( layer_midpoint_depth, gw_depth_static))
61  {
62  gw_fill_sl[sl] = cbm::bound_min( 0.0,
63  wlst_sl[sl] - (wl_sl[sl] + EcHySoilWaterChange( sl)));
64  wc_.accumulated_groundwater_access += gw_fill_sl[sl];
65  }
66  else
67  {
68  double const wl_new( wl_sl[sl] + EcHySoilWaterChange( sl));
69  double const wc_new( cbm::bound( wc_min_sl[sl], wl_new / sc_.h_sl[sl], wc_max_sl[sl]));
70  kst_bottom_gw_vertical = cbm::bound_min( 0.0,
71  ldndc::hydrology::hydraulic_conductivity(
72  wc_new,
73  sc_.vgm_sl[sl],
74  wc_max_sl[sl],
75  wc_min_sl[sl],
76  kst_sl[sl]));
77  gw_fill_sl[sl] = 0.0;
78  }
79  }
80 
81  {
82  size_t sl( soillayers_in->soil_layer_cnt()-1);
83  double const layer_midpoint_depth( sc_.depth_sl[sl] - 0.5 * sc_.h_sl[sl]);
84  if ( cbm::flt_greater_equal( layer_midpoint_depth, gw_depth_static))
85  {
86  gw_fill_sl[sl] = cbm::bound_min( 0.0,
87  wlst_sl[sl] - (wl_sl[sl] + EcHySoilWaterChange( sl)));
88  wc_.accumulated_groundwater_access += gw_fill_sl[sl];
89  }
90  else
91  {
92  double const wl_new( wl_sl[sl] + EcHySoilWaterChange( sl));
93  double const wc_new( cbm::bound( wc_min_sl[sl], wl_new / sc_.h_sl[sl], wc_max_sl[sl]));
94  kst_bottom_gw_vertical = cbm::bound_min( 0.0,
95  ldndc::hydrology::hydraulic_conductivity(
96  wc_new,
97  sc_.vgm_sl[sl],
98  wc_max_sl[sl],
99  wc_min_sl[sl],
100  kst_sl[sl]));
101  gw_fill_sl[sl] = 0.0;
102  }
103  }
104  }
105 
106  //capillary rise
107  if ( m_param->WCDNDC_HAVE_CAPILLARY_ACTION())
108  {
109  size_t const STEPS( 10);
110  for (size_t steps = 0; steps < STEPS; steps++)
111  {
112  for (size_t sl = 0; sl < soillayers_in->soil_layer_cnt()-1; sl++)
113  {
114  double const layer_midpoint_depth( sc_.depth_sl[sl] - 0.5 * sc_.h_sl[sl]);
115  if ( cbm::flt_greater_equal( layer_midpoint_depth, gw_depth_static))
116  {
117  break;
118  }
119 
120  /* Water contents with until now calculated water balance */
121  double const wl_new_0( wl_sl[sl] + EcHySoilWaterChange( sl));
122  double const wl_new_1( wl_sl[sl+1] + EcHySoilWaterChange( sl+1));
123 
124  double const wc_vg_0( cbm::bound( wc_min_sl[sl], wl_new_0 / sc_.h_sl[sl], wc_max_sl[sl]));
125  double const wc_vg_1( cbm::bound( wc_min_sl[sl+1], wl_new_1 / sc_.h_sl[sl+1], wc_max_sl[sl+1]));
126 
127  /* Unsaturated hydraulic conductivity with until now calculated water balance */
128  double const kust_0( cbm::bound_min( 0.0,
129  ldndc::hydrology::hydraulic_conductivity(
130  wc_vg_0, sc_.vgm_sl[sl],
131  wc_max_sl[sl], wc_min_sl[sl], 1.0/double(STEPS)*kst_sl[sl])));
132  double const kust_1( cbm::bound_min( 0.0,
133  ldndc::hydrology::hydraulic_conductivity(
134  wc_vg_1, sc_.vgm_sl[sl+1],
135  wc_max_sl[sl+1], wc_min_sl[sl+1], 1.0/double(STEPS)*kst_sl[sl+1])));
136 
137  double const capillary_pressure_0( ldndc::hydrology::capillary_pressure(
138  wl_new_0/sc_.h_sl[sl], sc_.vga_sl[sl], sc_.vgn_sl[sl], sc_.vgm_sl[sl],
139  wc_max_sl[sl], wc_min_sl[sl]));
140  double const capillary_pressure_1( ldndc::hydrology::capillary_pressure(
141  wl_new_1/sc_.h_sl[sl+1], sc_.vga_sl[sl+1], sc_.vgn_sl[sl+1], sc_.vgm_sl[sl+1],
142  wc_max_sl[sl], wc_min_sl[sl+1]));
143 
144  double const kust( cbm::flt_greater( capillary_pressure_0, capillary_pressure_1) ? kust_1 : kust_0 );
145  double const flow( (capillary_pressure_1 - capillary_pressure_0) / (0.5 * (sc_.h_sl[sl] + sc_.h_sl[sl+1])) * kust);
146 
147  /* downward flow*/
148  if ( cbm::flt_greater_zero( flow))
149  {
150  double const left( wl_sl[sl] + EcHySoilWaterChange( sl) - (wc_min_sl[sl] * sc_.h_sl[sl]));
151  double const space( wlst_sl[sl+1] - (wl_sl[sl+1] + EcHySoilWaterChange( sl+1)));
152 
153  if ( cbm::flt_greater_zero( left) &&
154  cbm::flt_greater_zero( space))
155  {
156  double const bound_flow( 1.0 / static_cast<double>(STEPS) * cbm::bound_max( flow, std::min( left, space)));
157  cr_fill_sl[sl] -= bound_flow;
158  cr_fill_sl[sl+1] += bound_flow;
159  }
160  }
161  /* upward flow */
162  else if ( cbm::flt_less( flow, 0.0))
163  {
164  double const left( wl_sl[sl+1] + EcHySoilWaterChange( sl+1) - (wc_min_sl[sl+1] * sc_.h_sl[sl+1]));
165  double const space( wlst_sl[sl] - (wl_sl[sl] + EcHySoilWaterChange( sl)));
166 
167  if ( cbm::flt_greater_zero( left) &&
168  cbm::flt_greater_zero( space))
169  {
170  double const bound_flow( cbm::bound_max( -flow, 1.0 / static_cast<double>(STEPS) * std::min( left, space)));
171  cr_fill_sl[sl] += bound_flow;
172  cr_fill_sl[sl+1] -= bound_flow;
173  }
174  }
175  }
176 
177  size_t sl( soillayers_in->soil_layer_cnt()-1);
178  double const layer_midpoint_depth( sc_.depth_sl[sl] - 0.5 * sc_.h_sl[sl]);
179  if ( cbm::flt_greater( gw_depth_static, layer_midpoint_depth))
180  {
181  /* Water contents with until now calculated water balance */
182  double const wl_new( wl_sl[sl] + EcHySoilWaterChange( sl));
183 
184  double const wc_vg( cbm::bound( wc_min_sl[sl], wl_new / sc_.h_sl[sl], wc_max_sl[sl]));
185 
186  /* Unsaturated hydraulic conductivity with until now calculated water balance */
187  double const kust( cbm::bound_min( 0.0,
188  ldndc::hydrology::hydraulic_conductivity(
189  wc_vg, sc_.vgm_sl[sl],
190  wc_max_sl[sl], wc_min_sl[sl], 1.0/double(STEPS)*kst_sl[sl])));
191 
192  double const capillary_pressure( ldndc::hydrology::capillary_pressure(
193  wl_new/sc_.h_sl[sl], sc_.vga_sl[sl], sc_.vgn_sl[sl], sc_.vgm_sl[sl],
194  wc_max_sl[sl], wc_min_sl[sl]));
195 
196  /* upward flow */
197  double const flow( -capillary_pressure / (gw_depth_static - layer_midpoint_depth) * kust);
198  if ( cbm::flt_less( flow, 0.0))
199  {
200  double const space( wlst_sl[sl] - (wl_sl[sl] + EcHySoilWaterChange( sl)));
201  if ( cbm::flt_greater_zero( space))
202  {
203  double const bound_flow( cbm::bound_max( -flow, 1.0 / static_cast<double>(STEPS) * space));
204  cr_fill_sl[sl] += bound_flow;
205  cr_fill_groundwater += bound_flow;
206  }
207  }
208  }
209  }
210  }
211 
212  return LDNDC_ERR_OK;
213 }
double gw_fill_surface
Definition: echy.h:128
double gw_depth_static
Definition: echy.h:72
lvector_t< double > kst_sl
Definition: echy.h:110
double cr_fill_groundwater
Definition: echy.h:131
lvector_t< double > wc_max_sl
Definition: echy.h:101
lvector_t< double > gw_fill_sl
Definition: echy.h:95
lvector_t< double > wl_sl
Definition: echy.h:113
lvector_t< double > wc_min_sl
Definition: echy.h:104
double EcHySoilWaterChange(size_t)
Definition: echy.cpp:417
lvector_t< double > wlst_sl
Definition: echy.h:122
lvector_t< double > cr_fill_sl
Definition: echy.h:92
Here is the call graph for this function:
Here is the caller graph for this function:

◆ EcHyIntegration()

lerr_t ldndc::EcHy::EcHyIntegration ( )
private

...

Integrates all water state variables.

References bypass_fill_sl, EcHySoilWaterChange(), gw_fill_surface, runoff, throughfall, wc_max_sl, wc_min_sl, wl_sl, and wlfl_sl.

Referenced by solve().

431 {
432  surface_water = cbm::bound_min( 0.0,
433  surface_water +
434  (throughfall + gw_fill_surface + irrigation - wlfl_sl[0] - runoff - bypass_fill_sl.sum()));
435 
436  for (size_t sl = 0; sl < soillayers_in->soil_layer_cnt(); sl++)
437  {
438  wl_sl[sl] = cbm::bound_min( 0.0, wl_sl[sl] + EcHySoilWaterChange( sl));
439  wc_.mskpa_sl[sl] = ldndc::hydrology::capillary_pressure( wl_sl[sl]/sc_.h_sl[sl], sc_.vga_sl[sl],
440  sc_.vgn_sl[sl], sc_.vgm_sl[sl], wc_max_sl[sl], wc_min_sl[sl]);
441  }
442 
443  return LDNDC_ERR_OK;
444 }
double gw_fill_surface
Definition: echy.h:128
lvector_t< double > wc_max_sl
Definition: echy.h:101
lvector_t< double > wl_sl
Definition: echy.h:113
lvector_t< double > wc_min_sl
Definition: echy.h:104
double runoff
Definition: echy.h:134
lvector_t< double > wlfl_sl
Definition: echy.h:89
double throughfall
Definition: echy.h:140
double EcHySoilWaterChange(size_t)
Definition: echy.cpp:417
lvector_t< double > bypass_fill_sl
Definition: echy.h:98
Here is the call graph for this function:
Here is the caller graph for this function:

◆ EcHySoilWaterChange()

double ldndc::EcHy::EcHySoilWaterChange ( size_t  _sl)
private

Integrates all water state variables.

References cr_fill_sl, evsws_sl, gw_fill_sl, trwl_sl, and wlfl_sl.

Referenced by EcHyGetAvailableWaterEvaporation(), EcHyGetAvailableWaterTranspiration(), EcHyGroundwater(), EcHyIntegration(), and EcHyIrrigation().

419 {
420  return wlfl_sl[_sl] - wlfl_sl[_sl+1] + cr_fill_sl[_sl] - trwl_sl[_sl] - evsws_sl[_sl] + gw_fill_sl[_sl];
421 }
lvector_t< double > evsws_sl
Definition: echy.h:107
lvector_t< double > gw_fill_sl
Definition: echy.h:95
lvector_t< double > wlfl_sl
Definition: echy.h:89
lvector_t< double > trwl_sl
Definition: echy.h:81
lvector_t< double > cr_fill_sl
Definition: echy.h:92
Here is the caller graph for this function:

◆ EcHySubsl2()

lerr_t ldndc::EcHy::EcHySubsl2 ( double const &  _cp,
double const &  _delta_z,
int const &  _sl,
double const &  _saturation,
double &  _flow 
)
private

...

This routine calculates the rate of capillary flow or percolation between groundwater table and root zone. The stationary flow is found by integration of dZL = K.d(MH)/(K + FLW), where Z= height above groundwater, MH= matric head, K= conductivity and FLW= chosen flow. In an iteration loop the correct flow is found. The integration goes at most over four intervals: [0,45], [45,170], [170,330] and [330,MH-rootzone] (last one on logarithmic scale).

Author
C. Rappoldt M. Wopereis
Date
January 1986, revised June 1990

Chapter 15 in documentation WOFOST Version 4.1 (1988)

References kst_sl.

244 {
245  //calculation of pf from matrix head
246  double pf( std::log10( _cp));
247 
248  //in case of small matric head (high water contents)
249  if ( cbm::flt_greater( 1.0, pf))
250  {
251  _flow = 0.0;
252  return LDNDC_ERR_OK;
253  }
254 
255  double elog10( 2.302585);
256  double logst4( 2.518514);
257 
258  double start[4] = {0.0, 45.0, 170.0, 330.0};
259 
260  //number and width of integration intervals
261  int iint( 0);
262  double del[4] = { 0.0, 0.0, 0.0, 0.0};
263  for (int i1 = 0; i1 < 4; i1++)
264  {
265  if (i1 < 3)
266  {
267  del[i1] = std::min( start[i1+1], _cp) - start[i1];
268  }
269  else
270  {
271  del[i1] = pf - logst4;
272  }
273  if (del[i1] <= 0.0)
274  {
275  break;
276  }
277  iint += 1;
278  }
279 
280  //preparation of three-point gaussian integration
281  double hulp[12] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
282  double conduc[12] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
283  for (int i1 = 0; i1 < iint; i1++)
284  {
285  for (int i2 = 0; i2 < 3; i2++)
286  {
287  double pgau[3] = {0.1127016654, 0.5, 0.8872983346};
288  double wgau[3] = {0.2777778, 0.4444444, 0.2777778};
289 
290  int i3( 3 * i1 + i2);
291 
292  //the three points in the full-width intervals are standard
293  double pfstan[9] = {0.705143, 1.352183, 1.601282, 1.771497, 2.031409, 2.192880, 2.274233, 2.397940, 2.494110};
294  double pfgau( pfstan[i3]);
295 
296  //the three points in the last interval are calculated
297  if ( i1 == (iint-1))
298  {
299  if ( iint < 4)
300  {
301  pfgau = std::log10( start[iint-1] + pgau[i2] * del[iint-1]);
302  }
303  else
304  {
305  pfgau = logst4 + pgau[i2] * del[iint-1];
306  }
307  }
308 
309  double const wcl_loc( ldndc::hydrology::water_content( std::exp(elog10 * pfgau), sc_.vga_sl[_sl], sc_.vgn_sl[_sl], sc_.vgm_sl[_sl], _saturation, 0.1));
310  conduc[i3] = ldndc::hydrology::hydraulic_conductivity(wcl_loc, sc_.vgm_sl[_sl], _saturation, sc_.wc_wp_sl[_sl], kst_sl[_sl] * cbm::CM_IN_M);
311  hulp[i3] = del[i1] * wgau[i2] * conduc[i3];
312  if (i3 > 8)
313  {
314  hulp[i3] = hulp[i3] * elog10 * std::exp( elog10 * pfgau);
315  }
316  }
317  }
318 
319 
320  //setting upper and lower limit
321  double const wcl_loc( ldndc::hydrology::water_content( _cp, sc_.vga_sl[_sl], sc_.vgn_sl[_sl], sc_.vgm_sl[_sl], _saturation, 0.1));
322  double const kms( ldndc::hydrology::hydraulic_conductivity(wcl_loc, sc_.vgm_sl[_sl], _saturation, sc_.wc_wp_sl[_sl], kst_sl[_sl] * cbm::CM_IN_M));
323  double fu( (_cp <= _delta_z) ? 0.0 : 1.27);
324  double fl( (_cp >= _delta_z) ? 0.0 : -kms);
325 
326 
327  if ( !cbm::flt_equal( _cp, _delta_z))
328  {
329  //iteration loop
330  int imax( 3 * iint);
331  for ( int i1 = 0; i1 < 14; i1++)
332  {
333  double flw( (fu + fl) / 2.0);
334  double df( (fu - fl) / 2.0);
335  if ( (df < 0.01) &&
336  ((df / std::abs(flw)) < 0.1))
337  {
338  break;
339  }
340 
341  double z( 0.0);
342  for ( int i2 = 0; i2 < imax; i2++)
343  {
344  z = z + hulp[i2] / (conduc[i2] + flw);
345  }
346  if (z >= _delta_z)
347  {
348  fl = flw;
349  }
350  if (z <= _delta_z)
351  {
352  fu = flw;
353  }
354  }
355  }
356 
357  //flow output in mm
358  _flow = 10.0 * (fu + fl) / 2.0;
359 
360  return LDNDC_ERR_OK;
361 }
lvector_t< double > kst_sl
Definition: echy.h:110

◆ solve()

lerr_t ldndc::EcHy::solve ( )

Kicks off computation for one time step.

References EcHyBalanceCheck(), EcHyBypassFlow(), EcHyEvapotranspiration(), EcHyFlood(), EcHyGroundwater(), EcHyIntegration(), EcHyIrrigation(), EcHyPercolation(), EcHyreset(), EcHySnowIce(), EcHyStepExit(), EcHyStepInit(), kst_bottom, kst_sl, runoff, runoff_method, throughfall, and wlfl_sl.

46 {
47  /* reset of all fluxes */
48  EcHyreset();
49 
50  /* flooding events */
51  lerr_t rc = EcHyFlood();
52  if ( rc != LDNDC_ERR_OK)
53  {
54  KLOGERROR("Handling flooding event failed in: ", name());
55  return rc;
56  }
57 
58  /* tasks:
59  * - update internal state (e.g., throughfall, ...)
60  * - calculate evapotranspiration on demand
61  */
62  rc = EcHyStepInit();
63  if ( rc != LDNDC_ERR_OK)
64  { return rc; }
65 
66  /* begin water balance */
67  double balance( -1.0);
68  EcHyBalanceCheck( balance);
69 
70  /* snow and ice calculated */
71  EcHySnowIce();
72 
73  /*
74  * apply irrigation triggered by
75  * - irrigation events
76  * - flooding events
77  */
79 
80  double const potential_infiltration( surface_water + irrigation + throughfall);
81  double bypass_flow( m_param->CRACK_FRACTION() * potential_infiltration);
82 
83  /* bypass flow */
84  EcHyBypassFlow( m_param->CRACK_DEPTH(), bypass_flow);
85  double const infiltration( potential_infiltration - bypass_flow);
86 
87  /* downward water flow */
88  wlfl_sl[0] = cbm::bound_max( infiltration, kst_sl[0]);
89  for ( size_t sl = 0; sl < soillayers_in->soil_layer_cnt(); ++sl)
90  {
91  EcHyPercolation( 1, sl);
92  }
93 
94  if ( cbm::is_valid( kst_bottom))
95  {
96  wlfl_sl[soillayers_in->soil_layer_cnt()] = cbm::bound_max( wlfl_sl[soillayers_in->soil_layer_cnt()],
97  kst_bottom);
98  }
99  if ( cbm::is_valid( kst_bottom_gw_lateral))
100  {
101  wlfl_sl[soillayers_in->soil_layer_cnt()] = cbm::bound_max( wlfl_sl[soillayers_in->soil_layer_cnt()],
102  kst_bottom_gw_lateral);
103  }
104  if ( cbm::is_valid( kst_bottom_gw_vertical))
105  {
106  wlfl_sl[soillayers_in->soil_layer_cnt()] = cbm::bound_max( wlfl_sl[soillayers_in->soil_layer_cnt()],
107  kst_bottom_gw_vertical);
108  }
109 
111 
112  /* upward water flow */
113  for ( int sl = soillayers_in->soil_layer_cnt()-1; sl >= 0; --sl)
114  {
115  EcHyPercolation( 2, sl);
116  }
117 
118  /* runoff */
119  if ( runoff_method == "curvenumber")
120  {
121  double const surface_water_in_mm( surface_water * cbm::MM_IN_M);
122  double const curvenumber( 70.0);
123 
124  //retention parameter [mm]
125  double const retention_factor( 25.4 * (1000.0 / curvenumber - 10));
126 
127  //runoff [mm]
128  double const q_surf( cbm::sqr( surface_water_in_mm) /
129  ((surface_water_in_mm + retention_factor) * lclock()->time_resolution()));
130 
131  runoff = cbm::bound( 0.0,
132  q_surf * cbm::M_IN_MM,
133  0.99 * (surface_water + throughfall + irrigation - wlfl_sl[0] - bypass_flow));
134  }
135  else
136  {
137  double const f_runoff( cbm::bound_max( m_param->FRUNOFF() / lclock()->time_resolution(), 1.0));
138  runoff = cbm::bound_min( 0.0, f_runoff * (surface_water + throughfall + irrigation - wlfl_sl[0] - bypass_flow - bund_height));
139  }
140 
141  /* groundwater interaction:
142  * - set soil layers water-saturated
143  * - capillary rise
144  */
145  EcHyGroundwater();
146 
147  /* integration of state variables */
148  EcHyIntegration();
149 
150  /* update external state */
151  EcHyStepExit();
152 
153  /* perform water balance */
154  rc = EcHyBalanceCheck( balance);
155  if ( rc){ return rc; }
156 
157  rc = EcHy_check_for_negative_value("exit");
158  if ( rc){ return rc; }
159 
160  return LDNDC_ERR_OK;
161 }
lvector_t< double > kst_sl
Definition: echy.h:110
lerr_t EcHySnowIce()
Calls SnowDNDC for the calculation of snowpack and soil ice formation.
lerr_t EcHyFlood()
sets hydrologic conditions during flooding events, e.g.,
Definition: echy-management.cpp:17
void EcHyreset()
...
Definition: echy.cpp:170
lerr_t EcHyBypassFlow(double, double &)
Calculates water percolation within the soil profile.
lerr_t EcHyStepInit()
...
Definition: echy.cpp:202
lerr_t EcHyIntegration()
...
Definition: echy.cpp:430
lerr_t EcHyEvapotranspiration()
Calculates evapotranspiration within the soil profile.
cbm::string_t runoff_method
Definition: echy.h:194
double kst_bottom
Definition: echy.h:67
double runoff
Definition: echy.h:134
lvector_t< double > wlfl_sl
Definition: echy.h:89
double throughfall
Definition: echy.h:140
lerr_t EcHyGroundwater()
...
Definition: echy-groundwater.cpp:18
lerr_t EcHyStepExit()
...
Definition: echy.cpp:305
lerr_t EcHyPercolation(size_t, size_t)
Calculates water percolation within the soil profile.
lerr_t EcHyBalanceCheck(double &)
...
Definition: echy.cpp:453
lerr_t EcHyIrrigation()
Irrigation.
Definition: echy-management.cpp:74
Here is the call graph for this function:

Member Data Documentation

◆ accumulated_irrigation_old

double ldndc::EcHy::accumulated_irrigation_old
private

Accumulated irrigation of last time step [m]

Referenced by EcHyIrrigation().

◆ accumulated_potentialtranspiration_old

double ldndc::EcHy::accumulated_potentialtranspiration_old
private

Accumulated potential transpiration of last time step [m]

Referenced by EcHyPotentialEvapotranspiration().

◆ bypass_fill_sl

lvector_t< double > ldndc::EcHy::bypass_fill_sl
private

Soillayer water input due to bypass flow

Referenced by EcHyIntegration(), and EcHyreset().

◆ cr_fill_groundwater

double ldndc::EcHy::cr_fill_groundwater
private

Water addition to last soil layer from groundwater water by cappillary rise (only used for water balance calculation)

Referenced by EcHyBalanceCheck(), EcHyGroundwater(), and EcHyreset().

◆ cr_fill_sl

lvector_t< double > ldndc::EcHy::cr_fill_sl
private

Soillayer water input due to capillary rise

Referenced by EcHyGroundwater(), EcHyreset(), and EcHySoilWaterChange().

◆ daily_potential_evapotranspiration

double ldndc::EcHy::daily_potential_evapotranspiration
private

◆ daily_potential_leaf_evaporation

double ldndc::EcHy::daily_potential_leaf_evaporation
private

◆ daily_potential_soil_evaporation

double ldndc::EcHy::daily_potential_soil_evaporation
private

◆ daily_potential_transpiration

double ldndc::EcHy::daily_potential_transpiration
private

◆ ev_leaf

double ldndc::EcHy::ev_leaf
private

Evaporation from plant surface

Referenced by EcHyBalanceCheck(), EcHyPotentialEvapotranspiration(), and EcHyStepExit().

◆ evapotranspiration_method

cbm::string_t ldndc::EcHy::evapotranspiration_method
private

◆ evsws_sl

lvector_t< double > ldndc::EcHy::evsws_sl
private

◆ gw_depth_static

double ldndc::EcHy::gw_depth_static
private

Depth of groundwater table [m]

Referenced by EcHyGroundwater(), and EcHyStepInit().

◆ gw_fill_sl

lvector_t< double > ldndc::EcHy::gw_fill_sl
private

Soillayer water input due to groundwater flow

Referenced by EcHyBalanceCheck(), EcHyGroundwater(), EcHyreset(), and EcHySoilWaterChange().

◆ gw_fill_surface

double ldndc::EcHy::gw_fill_surface
private

Water addition to surface water from groundwater water boundary condition

Referenced by EcHyBalanceCheck(), EcHyGroundwater(), EcHyIntegration(), and EcHyreset().

◆ interception_water

double ldndc::EcHy::interception_water
private

◆ kst_bottom

double ldndc::EcHy::kst_bottom
private

Saturated hydraulic conductivity below last soil layer [cm:min-1]

Referenced by EcHyFlood(), EcHyStepInit(), and solve().

◆ kst_sl

lvector_t< double > ldndc::EcHy::kst_sl
private

Saturated hydraulic conductivity

Referenced by EcHyFlood(), EcHyGroundwater(), EcHySubsl2(), and solve().

◆ m_icecontent_in

WaterCycleSnowDNDC::IceContentStateIn ldndc::EcHy::m_icecontent_in
private

...

◆ runoff

double ldndc::EcHy::runoff
private

Lateral surface runoff

Referenced by EcHyBalanceCheck(), EcHyIntegration(), EcHyreset(), EcHyStepExit(), and solve().

◆ runoff_method

cbm::string_t ldndc::EcHy::runoff_method
private

...

Referenced by solve().

◆ snowfall

double ldndc::EcHy::snowfall
private

Snowfall

Referenced by EcHyBalanceCheck(), and EcHyreset().

◆ thornthwaite_heat_index

double ldndc::EcHy::thornthwaite_heat_index
private

◆ throughfall

double ldndc::EcHy::throughfall
private

Throughfall to soil

Referenced by EcHyBalanceCheck(), EcHyIntegration(), EcHyStepExit(), EcHyStepInit(), and solve().

◆ trwl_sl

lvector_t< double > ldndc::EcHy::trwl_sl
private

Water withdrawl by transpiration [m d−1]

Referenced by EcHyBalanceCheck(), EcHyPotentialEvapotranspiration(), EcHyreset(), EcHySoilWaterChange(), and EcHyStepExit().

◆ wc_max_sl

lvector_t< double > ldndc::EcHy::wc_max_sl
private

Maximum water content

Referenced by EcHyGroundwater(), and EcHyIntegration().

◆ wc_min_sl

lvector_t< double > ldndc::EcHy::wc_min_sl
private

Minimum water content

Referenced by EcHyGetMinimumWater(), EcHyGroundwater(), and EcHyIntegration().

◆ wl_sl

lvector_t< double > ldndc::EcHy::wl_sl
private

◆ wlfc_sl

lvector_t< double > ldndc::EcHy::wlfc_sl
private

Amount of water in soil layer at field capacity

Referenced by EcHyGetAvailableWaterTranspiration(), EcHyGetWaterLimitationTranspiration(), and EcHyIrrigation().

◆ wlfl_sl

lvector_t< double > ldndc::EcHy::wlfl_sl
private

Water flux at boundaries of soil layer [m d-1] the flux of water between soil layer is tracked by wlfl (mm d−1). in total, there are nl+1 flow rates, where nl is the number of soil layers, wlfl[1] is the flow rate between the ponded water layer and the soil surface, wlfl[2] is the flow rate between soil layer 1 and soil layer 2, etc.

Referenced by EcHyBalanceCheck(), EcHyIntegration(), EcHyreset(), EcHySoilWaterChange(), EcHyStepExit(), and solve().

◆ wlst_sl

lvector_t< double > ldndc::EcHy::wlst_sl
private

Amount of water in soil layer at saturation

Referenced by EcHyGroundwater(), and EcHyIrrigation().

◆ wlwp_sl

lvector_t< double > ldndc::EcHy::wlwp_sl
private

Amount of water in soil layer at wilting point

Referenced by EcHyGetWiltingPoint().