5.3 Water Potential–Water Content Relations
5.3.2 Soil Water Retention Curve Functions
The soil water retention curve can be characterized by a variety of different mathematical functions. In this book, we present and use three alternative models, which have been extensively tested and are the most commonly used. We also introduce an additional model that is a modification of one of the three models presented.
Campbell model
Campbell (1974) describes the soil moisture characteristic curve by a power-law relation:
θ=
⎧⎪
⎨
⎪⎩ θs
ψm
ψe
–1/b
ifψm ≥ψe
θs ifψm < ψe
(5.27)
Water Potential–Water Content Relations 105 whereψm[J kg–1] is the water potential,ψe[J kg–1] is the air entry potential,θ[m3m–3] is the volumetric water content,θs[m3m–3] is the saturated volumetric water content and bis a shape parameter related to the pore size distribution of the porous medium. Here the water potential is expressed as an absolute value.
van Genuchten model
An alternative equation commonly used to describe the soil water retention curve is the van Genuchten (1980) equation,
Se(ψ) = θ–θr
θs–θr
= 1
[1 + (αψ)n]m (5.28)
Solving forθ, can be written as
θ=θr+ (θs–θr) 1
[1 + (αψ)n]m (5.29)
where Se is the degree of saturation, lying in the range [0, 1], andα, n, m, θs and θr
are fitting parameters. Different restrictions can be imposed on the parametersnandm depending on the shape of the curve. In particular, when only a limited range of water retention values are available (usually in the ‘wet’ range of the curve), it might be neces- sary to restrict the parametersnandm. More stable results are generally obtained when the restrictionm= 1 – 1/nis implemented for incomplete data sets.
Ippisch–van Genuchten model
Ippisch et al. (2006) pointed out that the van Genuchten model, under certain con- ditions, is problematic when water retention data are used to compute hydraulic conductivity, and they demonstrated that ifn<2 orαha >1 (wherehais the air-entry value of the soil, corresponding to the largest pore radius), the van Genuchten–Mualem model predicts erroneous hydraulic conductivities. A detailed description of the van Genuchten–Mualem model, and its limitations, is provided in Chapter 6.
The modified formulation, as proposed by Ippischet al.(2006), has the form
Se=
⎧⎨
⎩ 1
Sc[1 + (αψm)n]–mifψm≥ψe
1 ifψm< ψe
(5.30)
whereSe is the degree of saturation,α, mand nare fitting parameters, andSc = [1 + (αψe)n]–mis the water saturation at the air-entry potentialψe.
Modified evaluation of the residual water content
As pointed out by Campbell and Shiozawa (1992), the models just described do not correctly represent the soil water retention curve in the dry range and they give poor results at low water contents. Indeed, the concept of the existence of a soil residual water
106 Soil Liquid Phase and Soil–Water Interactions
content is an incorrect idea that does not represent experimental data. When accurate measurement of the soil water retention curve in the dry range are performed, as shown in Fig. 5.5, the water retention curve does not tend asymptotically to a ‘residual water content’, but decreases towards a zero value corresponding to ‘oven-dry’ matric poten- tial. Campbell and Shiozawa (1992) proposed a model where the ‘residual water content’
is not a constant, but a decreasing variable as described by the following equation:
θr=θr0
1 – ln(αψ+ 1) ln(αψ0+ 1)
(5.31) whereψ0 is the ‘oven-dry’ matric potential at zero water content, which is about 106 J kg–1, andθr0 corresponds to the original value of the ‘residual water content’ in the van Genuchten (1980) model. This modification improves the characterization of the soil water retention curve, without adding any additional parameters.
Campbell–Ippisch–van Genuchten model
In the present analysis, we have described the two main limitations of the van Genuchten (1980) model in the wet range and in the dry range. Modifications of the model in the wet range were proposed by Ippischet al.(2006) and in the dry range by Campbell and Shiozawa (1992), as described above. Here we are presenting a model where the two modifications are combined and incorporated into the original van Genuchten (1980) model. Therefore the model is an implementation of the Ippischet al.(2006) model, with the modified ‘residual water content’ proposed by Campbell and Shiozawa (1992).
Figure 5.6 shows a water retention curve fitted using the van Genuchten (1980) model, while Fig. 5.7 depicts a curve fitted using the Campbell–Ippisch–van Genuchten model.
100 10–1 10–2 10–3 10–4
10–5 101102103 104105106107108 0.0
0.1 0.2 0.3 0.4 0.5
Water potential [J kg–1]
Water content [m3 m–3]
Figure 5.6 Soil water retention curve for a soil sample fitted using the van Genuchten model.
Water Potential–Water Content Relations 107
100 10–1 10–2 10–3 10–4
10–5 101102103104105106107108 0.0
0.1 0.2 0.3 0.4 0.5
Water potential [J kg–1]
Water content [m3 m–3]
Figure 5.7 Soil water retention curve for a soil sample fitted using the Campbell–Ippisch–van Genuchten model. Note how the curve reaches a zero value of water content.
Note how the former reaches an asymptotic value of soil water content at dry water potentials, which does not represent the experimental data, while the latter reaches a zero value of water content, and correctly describes the experimental data.
Parameterization of the soil water retention curve can be obtained by (a) fitting a mathematical model to experimental data using least squares nonlinear fitting algorithms or neural networks, (b) employing inverse methods, which are methods where model parameters are iteratively changed so that a given selected hydrological model approxi- mates the observed response, and (c) using pedotransfer functions, which are regression equations based on the dependence of the soil water retention curves on basic soil prop- erties such as particle size distribution, porosity, bulk density and organic matter. Below we present a Python program for least squares, nonlinear fitting.
Fitting water retention curve models to experimental data
The problem of minimizing a nonlinear function over a space of parameters of the func- tion is usually referred as nonlinear fitting. These problems arise commonly in least squares curve fitting and nonlinear programming. The problem is formulated as
(β) = m
i=1
[yi–f(xi,β)]2 (5.32)
where there aremempirical data pairs (xi,yi). The objective function(β) is minimized by optimizing the parametersβ of the model f(x,β) so that the sum of the squares of the deviations is minimized.
108 Soil Liquid Phase and Soil–Water Interactions
The Levenberg–Marquardt algorithm (Levenberg, 1944; Marquardt, 1963) is an it- erative procedure where the user must provide an initial guess of the parameter vectorβ. Then, at each iteration,βis replaced by a new approximationβ+δ. This new parameter set will lead to a new sum of squares. The basis of the algorithm is a linear approximation of the functionf(x,β+δ) in the neighbourhood ofβ. Denoting the Jacobian matrix by J, a Taylor series expansion for smallδleads to
f(x,β+δ)≈f(x,β) +Jiδ (5.33) where
Ji= ∂f(xi,β)
∂β (5.34)
is the gradient off with respect toβ. The new objective function is now (β+δ) =
m i=1
[y–f(xi,β) –Jiδ]2 (5.35)
Therefore the soughtδ that minimizes this new objective function is the solution of the least squares problem. The iteration ends when the functionis less than a threshold for the error. One of the limitation of the Levenberg–Marquardt algorithm is that the solution for the best-fit parameters may depend on the initial conditions of the parameter set, and therefore the solution may not be unique.
Numerical implementation
A Python project calledPSP_waterRetentionFitting was implemented to apply nonlinear fitting to the models described above. Specifically, the user can select among the following functions (or models):
1. Campbell 2. van Genuchten
3. van Genuchten with the restrictionm= 1 – 1/n 4. Ippisch–van Genuchten
5. Campbell–Ippisch–van Genuchten
The code is written in a modular form, such that the user can easily write a different soil water retention curve model and include it in the program. Moreover, the program modularity allows the user to modify the program and use other equations to fit differ- ent data sets of other soil parametric functions. For instance, the Gaussian function for particle size distribution presented in Chapter 2 can be implemented using the present program, to parameterize particle size distribution models.
Water Potential–Water Content Relations 109 The program comprises four files:
1. main.py
2. PSP_readDataFile.py 3. PSP_Marquardt.py 4. PSP_waterRetention.py
Themain.py file is written to import the experimental data, select the water re- tention function, call the functions for nonlinear fitting and plot the results. The PSP_readDataFile.pyis written to read the experimental data and is described in Appendix A. ThePSP_waterRetention.pycontains the water retention functions, while thePSP_Marquardt.pyimplements the equation for least–squares algorithms.
To run the program, the user must run the filemain.py; then the user will be prompted with the following commands to select the water retention function:
1 Campbell 2 van Genuchten
3 van Genuchten with m = 1-1/n restriction 4 Ippisch-van Genuchten
5 Campbell-Ippisch-van Genuchten Choose model type: 1
The program then performs the computations, the results are printed on the screen and a plot is generated. The screen output is
Fitting
iterations nr: 23
sum of squared residuals: 0.00345163976933 thetaS = 0.46
AirEntry = 4.21150485478 b = 3.57866322236
The first section of the output for the statistical information is the number of iterations and the sum of square residuals. The second section has the water retention parameters.
For example, we can run Campbell’s equation for the experimental data stored in the file soil.txt, and the saturated water content, the air-entry potential and the parameterb are printed. These values will be used in Chapters 9 and 11 for numerical solutions to water flow.
An example of the fitting results is shown in Fig. 5.8 for the models listed above. The program’s output is one graph only for the selected model, but in Fig. 5.8, to show the different shapes of the curves using the different models, we have combined the four outputs. Note, for instance, how the selection of van Genuchten’s equation with the restrictionm= 1 – 1/ndetermined a different shape of the curve around the air-entry
110 Soil Liquid Phase and Soil–Water Interactions
100 10–1 10–2 10–3 10–4
10–5 101102103104105106107108 0.0
0.1 0.2 0.3 0.4 0.5
Water potential [J kg–1] Water content [m3 m–3]
100 10–1 10–2 10–3 10–4
10–5 101102103104105106107108 0.0
0.1 0.2 0.3 0.4 0.5
Water potential [J kg–1] Water content [m3 m–3]
100 10–1 10–2 10–3 10–4
10–5 101102103104105106107108 0.0
0.1 0.2 0.3 0.4 (b)0.5 (a)
(d) (c)
Water potential [J kg–1] Water content [m3 m–3]
100 10–1 10–2 10–3 10–4
10–5 101102103104105106107108 0.0
0.1 0.2 0.3 0.4 0.5
Water potential [J kg–1] Water content [m3 m–3]
Figure 5.8 Experimental and fitted water retention curves for a silty clay loam soil. The fitting was performed using (a) Campbell’s equation, (b) van Genuchten’s equation, (c) van Genuchten’s equation with the restriction m= 1 – 1/n and (d) the Campbell–Ippisch–van Genucthen equation.
potential compared with the curve obtained using van Genucthen’s equation with free parameters. Also note that the Campbell and Campbell–Ippisch–van Genuchten models are discontinous at the air-entry potential.
Themain.pyfile is shown below. The first lines are used to import modules and files. Then experimental data are read by using the file PSP_readDataFile.py The program then has a series of if and elif to print the choices regard- ing the selection of the water retention function. The function Marquardt() has arguments (waterRetentionCurve, b0, bmin, bmax, waterPotential, waterContent),which are the type of water retention function, the initial, minimum and maximum values of the parameters, and the experimental water potential and water content. The function returns an array of fitted parameters b, which can change in number and type depending on the selected model. The last section of the function maincomprises the usualmatplotlibinstructions to plot the graph with the results.
Water Potential–Water Content Relations 111
#PSP_waterRetentionFitting
from _ _future_ _ import print_function, division try: input = raw_input
except: pass import numpy as np
import matplotlib.pyplot as plt
from PSP_readDataFile import readDataFile from PSP_Marquardt import *
def main():
# read experimental values
myOutput, isFileOk = readDataFile("data/soil.txt", 1, ’\t’, False) if (not isFileOk):
print(’Wrong file: error reading row nr.’, myOutput) return(False)
waterPotential = myOutput[:,0]
waterContent = myOutput[:,1]
# select water retention curve print (CAMPBELL,’ Campbell’)
print (VAN_GENUCHTEN,’ van Genuchten’)
print (RESTRICTED_VG,’ van Genuchten with m = 1-1/n restriction’) print (IPPISCH_VG,’ Ippisch-van Genuchten’)
print (CAMPBELL_IPPISCH_VG,’ Campbell-Ippisch-van Genuchten’) waterRetentionCurve = 0
while (waterRetentionCurve < CAMPBELL) or
(waterRetentionCurve > CAMPBELL_IPPISCH_VG):
waterRetentionCurve = float(input("Choose model type: ")) if (waterRetentionCurve < CAMPBELL) or
(waterRetentionCurve > CAMPBELL_IPPISCH_VG):
print(’wrong choice.’)
# initialize parameters thetaS = max(waterContent)
#thetaR = min(waterContent) thetaR = 0.08
air_entry = 1.0 Campbell_b = 4.0 VG_alpha = 1/air_entry VG_n = 1.5
VG_m = 1. - 1./VG_n
if (waterRetentionCurve == CAMPBELL):
b0 = np.array([thetaS, air_entry, Campbell_b], float) bmin = np.array([thetaS, 0.1, 0.1], float)
112 Soil Liquid Phase and Soil–Water Interactions
bmax = np.array([thetaS*1.1, 20., 10.], float) elif (waterRetentionCurve == VAN_GENUCHTEN):
b0 = np.array([thetaS, thetaR, VG_alpha, VG_n, VG_m], float) bmin = np.array([thetaS, 0.0, 0.01, 0.01, 0.01], float) bmax = np.array([1.0, thetaR, 10., 10., 1.], float) elif (waterRetentionCurve == RESTRICTED_VG):
b0 = np.array([thetaS, thetaR, VG_alpha, VG_n], float) bmin = np.array([thetaS, 0.0, 0.01, 1.], float)
bmax = np.array([1, thetaR, 10., 10.], float) elif (waterRetentionCurve == IPPISCH_VG):
b0 = np.array([thetaS, thetaR, air_entry, VG_alpha, VG_n], float)
bmin = np.array([thetaS, 0.0, 0.1, 0.01, 1.], float) bmax = np.array([1, thetaR, 10., 10., 10.], float) elif (waterRetentionCurve == CAMPBELL_IPPISCH_VG):
b0 = np.array([thetaS, thetaR, air_entry, VG_alpha, VG_n], float)
bmin = np.array([thetaS, 0.0, 0.1, 0.01, 1.], float) bmax = np.array([1, thetaR, 10., 10., 10.], float) else:
print (’wrong choice.’) return(False)
print ("\nFitting")
b = Marquardt(waterRetentionCurve, b0, bmin, bmax, waterPotential, waterContent)
print ("\nthetaS = ", b[0])
if (waterRetentionCurve == CAMPBELL):
print ("AirEntry = ", b[1]) print ("b = ", b[2])
elif (waterRetentionCurve == VAN_GENUCHTEN):
print ("thetaR = ", b[1]) print ("alpha = ", b[2]) print ("n = ", b[3]) print ("m = ", b[4])
elif (waterRetentionCurve == RESTRICTED_VG):
print ("thetaR = ", b[1]) print ("alpha = ", b[2]) print ("n = ", b[3])
elif (waterRetentionCurve == IPPISCH_VG):
print ("thetaR = ", b[1]) print ("AirEntry = ", b[2]) print ("alpha = ", b[3]) print ("n = ", b[4])
elif (waterRetentionCurve == CAMPBELL_IPPISCH_VG):
print ("thetaR = ", b[1])
Water Potential–Water Content Relations 113 print ("AirEntry = ", b[2])
print ("alpha = ", b[3]) print ("n = ", b[4]) myWP = np.logspace(-5, 8, 500)
myWC = estimate(waterRetentionCurve, b, myWP) plt.figure(figsize=(10,8))
plt.plot(myWP, myWC,’k-’)
plt.plot(waterPotential, waterContent,’ko’) plt.xscale(’log’)
plt.xlabel(’Water Potential [J kg$^{-1}$]’,
fontsize=20,labelpad=8) plt.xticks(size=’16’)
plt.ylabel(’Water Content [m$^{3}$ m$^{-3}$]’,
fontsize=20,labelpad=8) plt.tick_params(axis=’both’, which=’major’, labelsize=20,pad=8) plt.tick_params(axis=’both’, which=’minor’, labelsize=20,pad=8) plt.yticks(size=’16’)
#plt.savefig(’waterRetention.eps’) plt.show()
main()
The filePSP_waterRetention.py contains the four functions used for fitting the experimental data, as described above. The reader can easily implement a different model and include it in this file. The first lines are written to assign a number to the model, such that the user can then select it. The function Campbell() implements the Campbell (1974) model. Note theifstatement used to discriminate between water potential values larger or smaller than the air-entry value, since this function is discon- tinuous at the air-entry value. In this code we used the general names water content and water potential within the function name, while the variables were namedthetaand psi, respectively. The van Genuchten (1980) model with no restriction imposed on the parameters, is presented as the next function. The van Genuchten (1980) model with the restrictionm= 1 – 1/nis implemented, while the Campbell–Ippisch–van Genuchten model is written in the last lines.
#PSP_waterRetention.py
from _ _future_ _ import division import numpy as np
CAMPBELL = 1 VAN_GENUCHTEN = 2 RESTRICTED_VG = 3 IPPISCH_VG = 4
CAMPBELL_IPPISCH_VG = 5
114 Soil Liquid Phase and Soil–Water Interactions def Campbell(v, psi, theta):
thetaS = v[0]
he = v[1]
Campbell_b= v[2]
for i in range(len(psi)):
if psi[i] <= he:
theta[i] = thetaS else:
Se = (psi[i]/he)**(-1./Campbell_b) theta[i] = Se * thetaS
def VanGenuchten(v, psi, theta):
thetaS = v[0]
VG_thetaR = v[1]
VG_alpha = v[2]
VG_n = v[3]
VG_m = v[4]
for i in range(len(psi)):
Se = 1. / pow(1. + pow(VG_alpha * psi[i], VG_n), VG_m) theta[i] = Se * (thetaS - VG_thetaR) + VG_thetaR def VanGenuchtenRestricted(v, psi, theta):
thetaS = v[0]
VG_thetaR = v[1]
VG_alpha = v[2]
VG_n = v[3]
VG_m = 1. - (1. / VG_n) for i in range(len(psi)):
if psi[i] <= 0:
Se = 0 else:
Se = (1. + (VG_alpha * abs(psi[i]))**VG_n)**(-VG_m) theta[i] = Se * (thetaS - VG_thetaR) + VG_thetaR
def IppischVanGenuchten(v, psi, theta):
thetaS = v[0]
VG_thetaR = v[1]
he = v[2]
VG_alpha = v[3]
VG_n = v[4]
VG_m = 1. - (1./VG_n)
VG_Sc = (1. + (VG_alpha * he)**VG_n)**VG_m for i in range(len(psi)):
if (psi[i] <= he):
Se = 1.0 else:
Se = VG_Sc * (1. + (VG_alpha * abs(psi[i]))**VG_n)**(-VG_m) theta[i] = Se * (thetaS - VG_thetaR) + VG_thetaR
Water Potential–Water Content Relations 115
def CampbellIppischVanGenuchten(v, psi, theta):
thetaS = v[0]
VG_thetaR = v[1]
he = v[2]
VG_alpha = v[3]
VG_n = v[4]
VG_m = 1. - (1./VG_n)
VG_Sc = (1. + (VG_alpha * he)**VG_n)**VG_m for i in range(len(psi)):
if (psi[i] <= he):
Se = 1.0 else:
Se = VG_Sc * (1. + (VG_alpha * abs(psi[i]))**VG_n)
**(-VG_m) residual = VG_thetaR * (1 -
((np.log(VG_alpha*psi[i] + 1.0)/np.log(VG_alpha*(10**6) + 1.0)))) theta[i] = max(0.0, Se * (thetaS - residual) + residual) The following code, implemented in the file PSP_Marquardt.py, contains the functions needed for the nonlinear fitting algorithm. The variables EPSILON and MAX_ITERATIONS_NRare the two convergence parameters: the precision and the max- imum number of iterations. The functionestimate() is written to pass the values of water content and water potential to the different retention curve models that were selected by the user. The functionMarquardt() contains the Marquardt (1963) algo- rithm. The functionNorm() computes the squared difference between the experimental datay[i]and the estimated datayEst[i], as described by the computation:dy= y[i]
- yEst[i] andnorm+= dy∗ dy Indeed, this algorithm is based on the minimization of the sum of the squared differences. The least squares algorithm is coded in the func- tionLeastSquares(). Note that in the first and secondforloops of this function, the parameters are changed and evaluated again to check if the new set is reducing the sum of the squared differences between the experimental and the fitted data. The final ob- jective is to minimize the sum of the squared differences to a number that is less than the accepted error. Clearly, the choice of the error parameter can significantly change the output. Moreover, this algorithm is subject to error due to the local minimum error.
#PSP_Marquardt.py
from _ _future_ _ import print_function, division import numpy as np
from math import sqrt
from PSP_waterRetention import * EPSILON = 0.00001
MAX_ITERATIONS_NR = 100
116 Soil Liquid Phase and Soil–Water Interactions
def Marquardt(waterRetentionCurve, v0, vmin, vmax, x, y):
n = len(v0) Lambda0 = 0.01 vFactor = 2.
l = np.array([Lambda0]*n) # damping parameters v = np.zeros(n, float)
for i in range(n): v[i] = v0[i]
nrIter = 1 maxDiff = 1.0
sse = norm(waterRetentionCurve, v0, x, y)
while (maxDiff > EPSILON) and (nrIter < MAX_ITERATIONS_NR):
diff = LeastSquares(waterRetentionCurve, l, v, vmin, vmax, x, y) maxDiff = max(abs(diff))
v_new = computeNewParameters(v, vmin, vmax, diff, l, vFactor) sse_new = norm(waterRetentionCurve, v_new, x, y)
if (sse_new < sse):
sse = sse_new
for i in range(n): v[i] = v_new[i]
l /= vFactor else:
l *= vFactor nrIter += 1
print ("iterations nr:", nrIter)
print ("sum of squared residuals:", sse) return(v)
def estimate(waterRetentionCurve, v, Psi):
waterContent = np.zeros(len(Psi)) if (waterRetentionCurve == CAMPBELL):
Campbell(v, Psi, waterContent)
elif (waterRetentionCurve == VAN_GENUCHTEN):
VanGenuchten(v, Psi, waterContent) elif (waterRetentionCurve == RESTRICTED_VG):
VanGenuchtenRestricted(v, Psi, waterContent) elif (waterRetentionCurve == IPPISCH_VG):
IppischVanGenuchten(v, Psi, waterContent) elif (waterRetentionCurve == CAMPBELL_IPPISCH_VG):
CampbellIppischVanGenuchten(v, Psi, waterContent) return(waterContent)
def computeNewParameters(v, vmin, vmax, diff, l, factor):
n = len(v)
v_new = np.zeros(n, float) for i in range(n):
Water Potential–Water Content Relations 117 v_new[i] = v[i] + diff[i]
if (v_new[i] > vmax[i]):
v_new[i] = vmax[i]
l[i] *= factor if (v_new[i] < vmin[i]):
v_new[i] = vmin[i]
l[i] *= factor return(v_new)
def norm(waterRetentionCurve, v, x, y):
yEst = estimate(waterRetentionCurve, v, x) norm = 0
for i in range(len(x)):
dy = y[i] - yEst[i]
norm += (dy*dy) return(norm)
def LeastSquares(waterRetentionCurve, l, v, vmin, vmax, x, y):
n = len(v) m = len(x)
p = np.resize(np.zeros(n, float),(n,m)) a = np.resize(np.zeros(n, float),(n,n)) z = np.zeros(n, float)
g = np.zeros(n, float) v1 = np.zeros(n, float) diff = np.zeros(n, float) for i in range(n): v1[i] = v[i]
est = estimate(waterRetentionCurve, v, x) for i in range(n):
change = (vmax[i] - vmin[i]) * 0.01 v1[i] += change
# get a new set of estimates
yEst = estimate(waterRetentionCurve, v1, x) v1[i] -= change
for j in range(m):
# compute derivatives
p[i][j] = (yEst[j] - est[j]) / change for i in range(n):
for j in range(i, n):
a[i][j] = 0
for k in range(m):
a[i][j] = a[i][j] + p[i][k] * p[j][k]
z[i] = sqrt(a[i][i]) + EPSILON
118 Soil Liquid Phase and Soil–Water Interactions for i in range(n):
g[i] = 0
for k in range(m):
g[i] = g[i] + p[i][k] * (y[k] - est[k]) g[i] = g[i] / z[i]
for j in range(i, n):
a[i][j] = a[i][j] / (z[i] * z[j]) for i in range(n):
a[i][i] = a[i][i] + l[i]
for j in range(i+1, n):
a[j][i] = a[i][j]
for j in range(n-1):
pivot = a[j][j]
for i in range(j+1, n):
mult = a[i][j] / pivot
for k in range(j+1, n): a[i][k] -= mult * a[j][k]
g[i] -= mult * g[j]
diff[n-1] = g[n-1] / a[n-1][n-1]
for i in range(n-2, -1, -1):
top = g[i]
for k in range(i+1, n):
top -= a[i][k] * diff[k]
diff[i] = top / a[i][i]
for i in range(n):
diff[i] /= z[i]
return(diff)
Estimated parameters for different textural classes
We present two tables with soil water retention curve parameters. Table 5.3 lists param- eters for the 12 textural classes for Campbell’s equation, while Table 5.4 lists parameters for van Genuchten’s equation and the Campbell–Ippisch–van Genuchten equation.
In spite of the difficulties encountered in producing soil water retention functions from texture data, the benefits, especially for simulation models, of being able to produce one from the other justify additional effort in this area. The relationship we produce here will be based on the definition of geometric mean diameter presented in Chapter 3.
For Campbell’s model, we expectψe to decrease (become more negative) andb to increase as the mean pore diameter becomes smaller (note that whenb= 0, all of the water is held at a single potential, and whenbapproaches infinity, no change in water content occurs whenψmchanges). We expect pore size and particle size to be correlated;