MODFLOW 6 version 6.9.0.dev0
USGS Modular Hydrologic Model
Loading...
Searching...
No Matches
smoothingmodule Module Reference

Functions/Subroutines

subroutine sscurve (x, range, dydx, y)
 SCurve.
subroutine scubiclinear (x, range, dydx, y)
 sCubicLinear
subroutine sramp (x, range, dydx, y)
 sRamp
subroutine scubic (x, range, dydx, y)
 sCubic
subroutine slinear (x, range, dydx, y)
 sLinear
subroutine squadratic (x, range, dydx, y)
 sQuadratic
subroutine schsmooth (d, smooth, dwdh)
 sChSmooth
real(dp) function slinearsaturation (top, bot, x)
 sLinearSaturation
real(dp) function scubicsaturation (top, bot, x, eps)
 sCubicSaturation
real(dp) function squadraticsaturation (top, bot, x, eps)
 sQuadraticSaturation
real(dp) function svangenuchtensaturation (top, bot, x, alpha, beta, sr)
 sQuadraticSaturation
real(dp) function squadraticsaturationderivative (top, bot, x, eps)
 Derivative of the quadratic saturation function.
real(dp) function sqsaturation (top, bot, x, c1, c2)
 sQSaturation
real(dp) function sqsaturationderivative (top, bot, x, c1, c2)
 sQSaturationDerivative
real(dp) function sslope (x, xi, yi, sm, sp, ta)
 sSlope
real(dp) function sslopederivative (x, xi, sm, sp, ta)
 sSlopeDerivative
real(dp) function squadratic0sp (x, xi, tomega)
 sQuadratic0sp
real(dp) function squadratic0spderivative (x, xi, tomega)
 sQuadratic0spDerivative
real(dp) function squadraticslope (x, xi, yi, sm, sp, tomega)
 sQuadraticSlope
real(dp) function squadraticslopederivative (x, xi, sm, sp, tomega)
 sQuadraticSlopeDerivative

Function/Subroutine Documentation

◆ schsmooth()

subroutine smoothingmodule::schsmooth ( real(dp), intent(in) d,
real(dp), intent(inout) smooth,
real(dp), intent(inout) dwdh )

Function to smooth channel variables during channel drying

Definition at line 196 of file SmoothingFunctions.f90.

197 real(DP), intent(in) :: d
198 real(DP), intent(inout) :: smooth
199 real(DP), intent(inout) :: dwdh
200 !
201 ! -- local variables
202 real(DP) :: s
203 real(DP) :: diff
204 real(DP) :: aa
205 real(DP) :: ad
206 real(DP) :: b
207 real(DP) :: x
208 real(DP) :: y
209 ! -- code
210 !
211 smooth = dzero
212 s = dem5
213 x = d
214 diff = x - s
215 if (diff > dzero) then
216 smooth = done
217 dwdh = dzero
218 else
219 aa = -done / (s**dtwo)
220 ad = -dtwo / (s**dtwo)
221 b = dtwo / s
222 y = aa * x**dtwo + b * x
223 dwdh = (ad * x + b)
224 if (x <= dzero) then
225 y = dzero
226 dwdh = dzero
227 else if (diff > -dem14) then
228 y = done
229 dwdh = dzero
230 end if
231 smooth = y
232 end if
Here is the caller graph for this function:

◆ scubic()

subroutine smoothingmodule::scubic ( real(dp), intent(inout) x,
real(dp), intent(inout) range,
real(dp), intent(inout) dydx,
real(dp), intent(inout) y )

Nonlinear smoothing function returns value between 0-1; cubic function

Definition at line 109 of file SmoothingFunctions.f90.

110 real(DP), intent(inout) :: x
111 real(DP), intent(inout) :: range
112 real(DP), intent(inout) :: dydx
113 real(DP), intent(inout) :: y
114 !--local variables
115 real(DP) :: s, aa, bb
116 real(DP) :: cof1, cof2, cof3
117 ! -- code
118 !
119 dydx = dzero
120 y = dzero
121 if (range < dprec) range = dprec
122 if (x < dprec) x = dprec
123 s = range
124 aa = -dsix / (s**dthree)
125 bb = -dsix / (s**dtwo)
126 cof1 = x**dtwo
127 cof2 = -(dtwo * x) / (s**dthree)
128 cof3 = dthree / (s**dtwo)
129 y = cof1 * (cof2 + cof3)
130 dydx = (aa * x**dtwo - bb * x)
131 if (x <= dzero) then
132 y = dzero
133 dydx = dzero
134 else if ((x - s) > -dprec) then
135 y = done
136 dydx = dzero
137 end if
Here is the caller graph for this function:

◆ scubiclinear()

subroutine smoothingmodule::scubiclinear ( real(dp), intent(in) x,
real(dp), intent(in) range,
real(dp), intent(inout) dydx,
real(dp), intent(inout) y )

Computes the s curve where dy/dx = 0 at x=0; and dy/dx = 1 at x=1. Smooths from zero to a slope of 1.

Definition at line 45 of file SmoothingFunctions.f90.

46 real(DP), intent(in) :: x
47 real(DP), intent(in) :: range
48 real(DP), intent(inout) :: dydx
49 real(DP), intent(inout) :: y
50 !--local variables
51 real(DP) :: s
52 real(DP) :: xs
53 ! -- code
54 !
55 s = range
56 if (s < dprec) s = dprec
57 xs = x / s
58 if (xs < dzero) xs = dzero
59 if (xs <= dzero) then
60 y = dzero
61 dydx = dzero
62 elseif (xs < done) then
63 y = -done * xs**dthree + dtwo * xs**dtwo
64 dydx = -dthree * xs**dtwo + dfour * xs
65 else
66 y = done
67 dydx = dzero
68 end if
Here is the caller graph for this function:

◆ scubicsaturation()

real(dp) function smoothingmodule::scubicsaturation ( real(dp), intent(in) top,
real(dp), intent(in) bot,
real(dp), intent(in) x,
real(dp), intent(in), optional eps )

Nonlinear cubic saturation function returns value between 0-1

Definition at line 264 of file SmoothingFunctions.f90.

265 ! -- return
266 real(DP) :: y
267 ! -- dummy variables
268 real(DP), intent(in) :: top
269 real(DP), intent(in) :: bot
270 real(DP), intent(in) :: x
271 real(DP), intent(in), optional :: eps
272 ! -- local
273 real(DP) :: teps
274 real(DP) :: w
275 real(DP) :: b
276 real(DP) :: s
277 real(DP) :: cof1
278 real(DP) :: cof2
279 ! -- code
280 !
281 if (present(eps)) then
282 teps = eps
283 else
284 teps = dem2
285 end if
286 w = x - bot
287 b = top - bot
288 s = teps * b
289 cof1 = done / (s**dtwo)
290 cof2 = dtwo / s
291 if (w < dzero) then
292 y = dzero
293 else if (w < s) then
294 y = -cof1 * (w**dthree) + cof2 * (w**dtwo)
295 else if (w < (b - s)) then
296 y = w / b
297 else if (w < b) then
298 y = done + cof1 * ((b - w)**dthree) - cof2 * ((b - w)**dtwo)
299 else
300 y = done
301 end if
302
Here is the caller graph for this function:

◆ slinear()

subroutine smoothingmodule::slinear ( real(dp), intent(inout) x,
real(dp), intent(inout) range,
real(dp), intent(inout) dydx,
real(dp), intent(inout) y )

Linear smoothing function returns value between 0-1

Definition at line 144 of file SmoothingFunctions.f90.

145 real(DP), intent(inout) :: x
146 real(DP), intent(inout) :: range
147 real(DP), intent(inout) :: dydx
148 real(DP), intent(inout) :: y
149 !--local variables
150 real(DP) :: s
151 ! -- code
152 !
153 dydx = dzero
154 y = dzero
155 if (range < dprec) range = dprec
156 if (x < dprec) x = dprec
157 s = range
158 y = done - (s - x) / s
159 dydx = done / s
160 if (y > done) then
161 y = done
162 dydx = dzero
163 end if
Here is the caller graph for this function:

◆ slinearsaturation()

real(dp) function smoothingmodule::slinearsaturation ( real(dp), intent(in) top,
real(dp), intent(in) bot,
real(dp), intent(in) x )

Linear saturation function returns value between 0-1

Definition at line 239 of file SmoothingFunctions.f90.

240 ! -- return
241 real(DP) :: y
242 ! -- dummy variables
243 real(DP), intent(in) :: top
244 real(DP), intent(in) :: bot
245 real(DP), intent(in) :: x
246 ! -- local
247 real(DP) :: b
248 ! -- code
249 !
250 b = top - bot
251 if (x < bot) then
252 y = dzero
253 else if (x > top) then
254 y = done
255 else
256 y = (x - bot) / b
257 end if

◆ sqsaturation()

real(dp) function smoothingmodule::sqsaturation ( real(dp), intent(in) top,
real(dp), intent(in) bot,
real(dp), intent(in) x,
real(dp), intent(in), optional c1,
real(dp), intent(in), optional c2 )

Nonlinear smoothing function returns value between 0-1

Definition at line 446 of file SmoothingFunctions.f90.

447 ! -- return
448 real(DP) :: y
449 ! -- dummy variables
450 real(DP), intent(in) :: top
451 real(DP), intent(in) :: bot
452 real(DP), intent(in) :: x
453 real(DP), intent(in), optional :: c1
454 real(DP), intent(in), optional :: c2
455 ! -- local
456 real(DP) :: w
457 real(DP) :: b
458 real(DP) :: s
459 real(DP) :: cof1
460 real(DP) :: cof2
461 ! -- code
462 !
463 ! -- process optional variables
464 if (present(c1)) then
465 cof1 = c1
466 else
467 cof1 = -dtwo
468 end if
469 if (present(c2)) then
470 cof2 = c2
471 else
472 cof2 = dthree
473 end if
474 !
475 ! -- calculate head difference from bottom (w),
476 ! calculate range (b), and
477 ! calculate normalized head difference from bottom (s)
478 w = x - bot
479 b = top - bot
480 s = w / b
481 !
482 ! -- divide cof1 and cof2 by range to the power 3 and 2, respectively
483 cof1 = cof1 / b**dthree
484 cof2 = cof2 / b**dtwo
485 !
486 ! -- calculate fraction
487 if (s < dzero) then
488 y = dzero
489 else if (s < done) then
490 y = cof1 * w**dthree + cof2 * w**dtwo
491 else
492 y = done
493 end if
Here is the caller graph for this function:

◆ sqsaturationderivative()

real(dp) function smoothingmodule::sqsaturationderivative ( real(dp), intent(in) top,
real(dp), intent(in) bot,
real(dp), intent(in) x,
real(dp), intent(in), optional c1,
real(dp), intent(in), optional c2 )

Nonlinear smoothing function returns value between 0-1

Definition at line 500 of file SmoothingFunctions.f90.

501 ! -- return
502 real(DP) :: y
503 ! -- dummy variables
504 real(DP), intent(in) :: top
505 real(DP), intent(in) :: bot
506 real(DP), intent(in) :: x
507 real(DP), intent(in), optional :: c1
508 real(DP), intent(in), optional :: c2
509 ! -- local
510 real(DP) :: w
511 real(DP) :: b
512 real(DP) :: s
513 real(DP) :: cof1
514 real(DP) :: cof2
515 ! -- code
516 !
517 !
518 ! -- process optional variables
519 if (present(c1)) then
520 cof1 = c1
521 else
522 cof1 = -dtwo
523 end if
524 if (present(c2)) then
525 cof2 = c2
526 else
527 cof2 = dthree
528 end if
529 !
530 ! -- calculate head difference from bottom (w),
531 ! calculate range (b), and
532 ! calculate normalized head difference from bottom (s)
533 w = x - bot
534 b = top - bot
535 s = w / b
536 !
537 ! -- multiply cof1 and cof2 by 3 and 2, respectively, and then
538 ! divide by range to the power 3 and 2, respectively
539 cof1 = cof1 * dthree / b**dthree
540 cof2 = cof2 * dtwo / b**dtwo
541 !
542 ! -- calculate derivative of fraction with respect to x
543 if (s < dzero) then
544 y = dzero
545 else if (s < done) then
546 y = cof1 * w**dtwo + cof2 * w
547 else
548 y = dzero
549 end if
Here is the caller graph for this function:

◆ squadratic()

subroutine smoothingmodule::squadratic ( real(dp), intent(inout) x,
real(dp), intent(inout) range,
real(dp), intent(inout) dydx,
real(dp), intent(inout) y )

Nonlinear quadratic smoothing function returns value between 0-1

Definition at line 170 of file SmoothingFunctions.f90.

171 real(DP), intent(inout) :: x
172 real(DP), intent(inout) :: range
173 real(DP), intent(inout) :: dydx
174 real(DP), intent(inout) :: y
175 !--local variables
176 real(DP) :: s
177 ! -- code
178 !
179 dydx = dzero
180 y = dzero
181 if (range < dprec) range = dprec
182 if (x < dprec) x = dprec
183 s = range
184 y = (x**dtwo) / (s**dtwo)
185 dydx = dtwo * x / (s**dtwo)
186 if (y > done) then
187 y = done
188 dydx = dzero
189 end if
Here is the caller graph for this function:

◆ squadratic0sp()

real(dp) function smoothingmodule::squadratic0sp ( real(dp), intent(in) x,
real(dp), intent(in) xi,
real(dp), intent(in), optional tomega )

Nonlinear smoothing function returns a smoothed value of y that uses a quadratic to smooth x over range of xi - epsilon to xi + epsilon. Simplification of sQuadraticSlope with sm = 0, sp = 1, and yi = 0. From Panday et al. (2013) - eq. 35 - https://dx.doi.org/10.5066/F7R20ZFJ

Definition at line 652 of file SmoothingFunctions.f90.

653 ! -- return
654 real(DP) :: y
655 ! -- dummy variables
656 real(DP), intent(in) :: x
657 real(DP), intent(in) :: xi
658 real(DP), optional, intent(in) :: tomega
659 ! -- local
660 real(DP) :: omega
661 real(DP) :: epsilon
662 real(DP) :: dx
663 !
664 ! -- set smoothing interval
665 if (present(tomega)) then
666 omega = tomega
667 else
668 omega = dem6
669 end if
670 !
671 ! -- set smoothing interval
672 epsilon = dhalf * omega
673 !
674 ! -- calculate distance from xi
675 dx = x - xi
676 !
677 ! -- evaluate smoothing function
678 if (dx < -epsilon) then
679 y = xi
680 else if (dx < epsilon) then
681 y = (dx**dtwo / (dfour * epsilon)) + dhalf * dx + (epsilon / dfour) + xi
682 else
683 y = x
684 end if
Here is the caller graph for this function:

◆ squadratic0spderivative()

real(dp) function smoothingmodule::squadratic0spderivative ( real(dp), intent(in) x,
real(dp), intent(in) xi,
real(dp), intent(in), optional tomega )

Derivative of nonlinear smoothing function returns a smoothed value of y that uses a quadratic to smooth x over range of xi - epsilon to xi + epsilon. Simplification of sQuadraticSlope with sm = 0, sp = 1, and yi = 0. From Panday et al. (2013) - eq. 35 - https://dx.doi.org/10.5066/F7R20ZFJ

Definition at line 694 of file SmoothingFunctions.f90.

695 ! -- return
696 real(DP) :: y
697 ! -- dummy variables
698 real(DP), intent(in) :: x
699 real(DP), intent(in) :: xi
700 real(DP), optional, intent(in) :: tomega
701 ! -- local
702 real(DP) :: omega
703 real(DP) :: epsilon
704 real(DP) :: dx
705 !
706 ! -- set smoothing interval
707 if (present(tomega)) then
708 omega = tomega
709 else
710 omega = dem6
711 end if
712 !
713 ! -- set smoothing interval
714 epsilon = dhalf * omega
715 !
716 ! -- calculate distance from xi
717 dx = x - xi
718 !
719 ! -- evaluate smoothing function
720 if (dx < -epsilon) then
721 y = 0
722 else if (dx < epsilon) then
723 y = (dx / omega) + dhalf
724 else
725 y = 1
726 end if
Here is the caller graph for this function:

◆ squadraticsaturation()

real(dp) function smoothingmodule::squadraticsaturation ( real(dp), intent(in) top,
real(dp), intent(in) bot,
real(dp), intent(in) x,
real(dp), intent(in), optional eps )

Nonlinear quadratic saturation function returns value between 0-1

Definition at line 309 of file SmoothingFunctions.f90.

310 ! -- return
311 real(DP) :: y
312 ! -- dummy variables
313 real(DP), intent(in) :: top
314 real(DP), intent(in) :: bot
315 real(DP), intent(in) :: x
316 real(DP), optional, intent(in) :: eps
317 ! -- local
318 real(DP) :: teps
319 real(DP) :: b
320 real(DP) :: br
321 real(DP) :: bri
322 real(DP) :: av
323 ! -- code
324 !
325 if (present(eps)) then
326 teps = eps
327 else
328 teps = dem6
329 end if
330 b = top - bot
331 if (b > dzero) then
332 if (x < bot) then
333 br = dzero
334 else if (x > top) then
335 br = done
336 else
337 br = (x - bot) / b
338 end if
339 av = done / (done - teps)
340 bri = done - br
341 if (br < teps) then
342 y = av * dhalf * (br * br) / teps
343 elseif (br < (done - teps)) then
344 y = av * br + dhalf * (done - av)
345 elseif (br < done) then
346 y = done - ((av * dhalf * (bri * bri)) / teps)
347 else
348 y = done
349 end if
350 else
351 if (x < bot) then
352 y = dzero
353 else
354 y = done
355 end if
356 end if
357
Here is the caller graph for this function:

◆ squadraticsaturationderivative()

real(dp) function smoothingmodule::squadraticsaturationderivative ( real(dp), intent(in) top,
real(dp), intent(in) bot,
real(dp), intent(in) x,
real(dp), intent(in), optional eps )

Derivative of nonlinear smoothing function returns value between 0-1;

Definition at line 398 of file SmoothingFunctions.f90.

399 ! -- return
400 real(DP) :: y
401 ! -- dummy variables
402 real(DP), intent(in) :: top
403 real(DP), intent(in) :: bot
404 real(DP), intent(in) :: x
405 real(DP), optional, intent(in) :: eps
406 ! -- local
407 real(DP) :: teps
408 real(DP) :: b
409 real(DP) :: br
410 real(DP) :: bri
411 real(DP) :: av
412 ! -- code
413 !
414 if (present(eps)) then
415 teps = eps
416 else
417 teps = dem6
418 end if
419 b = top - bot
420 if (x < bot) then
421 br = dzero
422 else if (x > top) then
423 br = done
424 else
425 br = (x - bot) / b
426 end if
427 av = done / (done - teps)
428 bri = done - br
429 if (br < teps) then
430 y = av * br / teps
431 elseif (br < (done - teps)) then
432 y = av
433 elseif (br < done) then
434 y = av * bri / teps
435 else
436 y = dzero
437 end if
438 y = y / b
439
Here is the caller graph for this function:

◆ squadraticslope()

real(dp) function smoothingmodule::squadraticslope ( real(dp), intent(in) x,
real(dp), intent(in) xi,
real(dp), intent(in) yi,
real(dp), intent(in) sm,
real(dp), intent(in) sp,
real(dp), intent(in), optional tomega )

Quadratic smoothing function returns a smoothed value of y whose limbs are the lines yi + (sm * dx) for x-values less than xi and yi + (sp * dx) for x-values greater than xi, where dx = x - xi. The limbs are blended by a quadratic over xi +/- epsilon, so the value equals yi at xi only in the limit of zero smoothing; otherwise it differs from yi by a term proportional to the smoothing interval.

Definition at line 738 of file SmoothingFunctions.f90.

739 ! -- return
740 real(DP) :: y
741 ! -- dummy variables
742 real(DP), intent(in) :: x
743 real(DP), intent(in) :: xi
744 real(DP), intent(in) :: yi
745 real(DP), intent(in) :: sm
746 real(DP), intent(in) :: sp
747 real(DP), optional, intent(in) :: tomega
748 ! -- local
749 real(DP) :: omega
750 real(DP) :: epsilon
751 real(DP) :: dx
752 real(DP) :: c
753 !
754 ! -- set smoothing interval
755 if (present(tomega)) then
756 omega = tomega
757 else
758 omega = dem6
759 end if
760 !
761 ! -- set smoothing interval
762 epsilon = dhalf * omega
763 !
764 ! -- calculate distance from xi
765 dx = x - xi
766 !
767 ! -- evaluate smoothing function
768 if (dx < -epsilon) then
769 y = sm * dx
770 else if (dx < epsilon) then
771 c = dx / epsilon
772 y = dhalf * epsilon * (dhalf * (sp - sm) * (done + c**dtwo) + (sm + sp) * c)
773 else
774 y = sp * dx
775 end if
776 !
777 ! -- add value at xi
778 y = y + yi

◆ squadraticslopederivative()

real(dp) function smoothingmodule::squadraticslopederivative ( real(dp), intent(in) x,
real(dp), intent(in) xi,
real(dp), intent(in) sm,
real(dp), intent(in) sp,
real(dp), intent(in), optional tomega )

Derivative of sQuadraticSlope: smoothly transitions from the slope sm for x-values less than xi to the slope sp for x-values greater than xi, blended by a line over xi +/- epsilon, where dx = x - xi.

Definition at line 787 of file SmoothingFunctions.f90.

788 ! -- return
789 real(DP) :: y
790 ! -- dummy variables
791 real(DP), intent(in) :: x
792 real(DP), intent(in) :: xi
793 real(DP), intent(in) :: sm
794 real(DP), intent(in) :: sp
795 real(DP), optional, intent(in) :: tomega
796 ! -- local
797 real(DP) :: omega
798 real(DP) :: epsilon
799 real(DP) :: dx
800 real(DP) :: c
801 !
802 ! -- set smoothing interval
803 if (present(tomega)) then
804 omega = tomega
805 else
806 omega = dem6
807 end if
808 !
809 ! -- set smoothing interval
810 epsilon = dhalf * omega
811 !
812 ! -- calculate distance from xi
813 dx = x - xi
814 !
815 ! -- evaluate smoothing function
816 if (dx < -epsilon) then
817 y = sm
818 else if (dx < epsilon) then
819 c = dx / epsilon
820 y = dhalf * ((sp - sm) * c + (sm + sp))
821 else
822 y = sp
823 end if

◆ sramp()

subroutine smoothingmodule::sramp ( real(dp), intent(in) x,
real(dp), intent(in) range,
real(dp), intent(inout) dydx,
real(dp), intent(inout) y )

Smoothed ramp function; a smooth approximation of max(x, 0) with a continuous value and slope. The value is zero with zero slope for x <= 0 and is the exact line x with unit slope for x >= range, joined by a cubic over (0, range). Unlike sCubicLinear, which levels off at 1, the value continues with unit slope, so it is exact outside the transition (max(x, 0) for |x| >= range).

Definition at line 80 of file SmoothingFunctions.f90.

81 real(DP), intent(in) :: x
82 real(DP), intent(in) :: range
83 real(DP), intent(inout) :: dydx
84 real(DP), intent(inout) :: y
85 !--local variables
86 real(DP) :: s
87 real(DP) :: xs
88 ! -- code
89 !
90 s = range
91 if (s < dprec) s = dprec
92 xs = x / s
93 if (xs <= dzero) then
94 y = dzero
95 dydx = dzero
96 elseif (xs < done) then
97 y = x * xs * (dtwo - xs)
98 dydx = xs * (dfour - dthree * xs)
99 else
100 y = x
101 dydx = done
102 end if

◆ sscurve()

subroutine smoothingmodule::sscurve ( real(dp), intent(in) x,
real(dp), intent(in) range,
real(dp), intent(inout) dydx,
real(dp), intent(inout) y )

Computes the S curve for smooth derivatives between x=0 and x=1 from mfusg smooth subroutine in gwf2wel7u1.f

Definition at line 14 of file SmoothingFunctions.f90.

15 real(DP), intent(in) :: x
16 real(DP), intent(in) :: range
17 real(DP), intent(inout) :: dydx
18 real(DP), intent(inout) :: y
19 !--local variables
20 real(DP) :: s
21 real(DP) :: xs
22 ! -- code
23 !
24 s = range
25 if (s < dprec) s = dprec
26 xs = x / s
27 if (xs < dzero) xs = dzero
28 if (xs <= dzero) then
29 y = dzero
30 dydx = dzero
31 elseif (xs < done) then
32 y = -dtwo * xs**dthree + dthree * xs**dtwo
33 dydx = -dsix * xs**dtwo + dsix * xs
34 else
35 y = done
36 dydx = dzero
37 end if
Here is the caller graph for this function:

◆ sslope()

real(dp) function smoothingmodule::sslope ( real(dp), intent(in) x,
real(dp), intent(in) xi,
real(dp), intent(in) yi,
real(dp), intent(in) sm,
real(dp), intent(in) sp,
real(dp), intent(in), optional ta )

Nonlinear smoothing function returns a smoothed value of y whose limbs are the lines yi + (sm * dx) for x-values less than xi and yi + (sp * dx) for x-values greater than xi, where dx = x - xi. The slope change at xi is smoothed with the hyperbolic smoothed min and max of Chen and Mangasarian (1996), as applied to hydrologic-model thresholds by Kavetski and Kuczera (2007, eq. 18; https://dx.doi.org/10.1029/2006WR005195); here the smoothing constant is b**2 - a**2 with b = a / (sqrt(2) - 1). Currently unused.

Definition at line 562 of file SmoothingFunctions.f90.

563 ! -- return
564 real(DP) :: y
565 ! -- dummy variables
566 real(DP), intent(in) :: x
567 real(DP), intent(in) :: xi
568 real(DP), intent(in) :: yi
569 real(DP), intent(in) :: sm
570 real(DP), intent(in) :: sp
571 real(DP), optional, intent(in) :: ta
572 ! -- local
573 real(DP) :: a
574 real(DP) :: b
575 real(DP) :: dx
576 real(DP) :: xm
577 real(DP) :: xp
578 real(DP) :: ym
579 real(DP) :: yp
580 !
581 ! -- set smoothing variable a
582 if (present(ta)) then
583 a = ta
584 else
585 a = dem8
586 end if
587 !
588 ! -- calculate b from smoothing variable a
589 b = a / (sqrt(dtwo) - done)
590 !
591 ! -- calculate contributions to y. xm and xp are smoothed values of
592 ! min(x, xi) and max(x, xi), so the limbs are yi + sm*dx (x < xi) and
593 ! yi + sp*dx (x > xi).
594 dx = x - xi
595 xm = dhalf * (x + xi - sqrt(dx**dtwo + b**dtwo - a**dtwo))
596 xp = dhalf * (x + xi + sqrt(dx**dtwo + b**dtwo - a**dtwo))
597 ym = sm * (xm - xi)
598 yp = sp * (xp - xi)
599 !
600 ! -- calculate y from ym and yp contributions
601 y = yi + ym + yp

◆ sslopederivative()

real(dp) function smoothingmodule::sslopederivative ( real(dp), intent(in) x,
real(dp), intent(in) xi,
real(dp), intent(in) sm,
real(dp), intent(in) sp,
real(dp), intent(in), optional ta )

Derivative of sSlope (see that routine for the provenance): smoothly transitions from slope sm for x-values less than xi to slope sp for x-values greater than xi, where dx = x - xi.

Definition at line 610 of file SmoothingFunctions.f90.

611 ! -- return
612 real(DP) :: y
613 ! -- dummy variables
614 real(DP), intent(in) :: x
615 real(DP), intent(in) :: xi
616 real(DP), intent(in) :: sm
617 real(DP), intent(in) :: sp
618 real(DP), optional, intent(in) :: ta
619 ! -- local
620 real(DP) :: a
621 real(DP) :: b
622 real(DP) :: dx
623 real(DP) :: mu
624 real(DP) :: rho
625 !
626 ! -- set smoothing variable a
627 if (present(ta)) then
628 a = ta
629 else
630 a = dem8
631 end if
632 !
633 ! -- calculate b from smoothing variable a
634 b = a / (sqrt(dtwo) - done)
635 !
636 ! -- calculate contributions to derivative
637 dx = x - xi
638 mu = sqrt(dx**dtwo + b**dtwo - a**dtwo)
639 rho = dx / mu
640 !
641 ! -- calculate derivative from individual contributions
642 y = dhalf * (sm + sp) - dhalf * rho * (sm - sp)

◆ svangenuchtensaturation()

real(dp) function smoothingmodule::svangenuchtensaturation ( real(dp), intent(in) top,
real(dp), intent(in) bot,
real(dp), intent(in) x,
real(dp), intent(in) alpha,
real(dp), intent(in) beta,
real(dp), intent(in) sr )

van Genuchten saturation function returns value between 0-1

Definition at line 364 of file SmoothingFunctions.f90.

365 ! -- return
366 real(DP) :: y
367 ! -- dummy variables
368 real(DP), intent(in) :: top
369 real(DP), intent(in) :: bot
370 real(DP), intent(in) :: x
371 real(DP), intent(in) :: alpha
372 real(DP), intent(in) :: beta
373 real(DP), intent(in) :: sr
374 ! -- local
375 real(DP) :: b
376 real(DP) :: pc
377 real(DP) :: gamma
378 real(DP) :: seff
379 ! -- code
380 !
381 b = top - bot
382 pc = (dhalf * b) - x
383 if (pc <= dzero) then
384 y = dzero
385 else
386 gamma = done - (done / beta)
387 seff = (done + (alpha * pc)**beta)**gamma
388 seff = done / seff
389 y = seff * (done - sr) + sr
390 end if
391