module SoilWaterRetentionCurveMod !--------------------------------------------------------------------------- ! !DESCRIPTION: ! Abstract base class for functions to compute soil water retention curve ! ! !USES: implicit none save private ! ! !PUBLIC TYPES: public :: soil_water_retention_curve_type type, abstract :: soil_water_retention_curve_type private contains ! compute hydraulic conductivity procedure(soil_hk_interface), deferred :: soil_hk ! compute soil suction potential procedure(soil_suction_interface), deferred :: soil_suction ! compute relative saturation at which soil suction is equal to a target value procedure(soil_suction_inverse_interface), deferred :: soil_suction_inverse end type soil_water_retention_curve_type abstract interface ! Note: The following interfaces are set up based on the arguments needed for the ! clapphornberg1978 implementations. It's likely that these interfaces are not ! totally general for all desired implementations. In that case, we'll need to think ! about how to support different interfaces. Some possible solutions are: ! ! - Make the interfaces contain all possible inputs that are needed by any ! implementation; each implementation will then ignore the inputs it doesn't need. ! ! - For inputs that are needed only by particular implementations - and particularly ! for inputs that are constant in time (e.g., this is the case for bsw, I think): ! pass these into the constructor, and save pointers to these inputs as components ! of the child type that needs them. Then they aren't needed as inputs to the ! individual routines, allowing the interfaces for these routines to remain more ! consistent between different implementations. subroutine soil_hk_interface(this, c, j, s, imped, soilstate_inst, & hk, dhkds) ! !DESCRIPTION: ! Compute hydraulic conductivity ! ! !USES: use shr_kind_mod , only : r8 => shr_kind_r8 use SoilStateType , only : soilstate_type import :: soil_water_retention_curve_type ! ! !ARGUMENTS: class(soil_water_retention_curve_type), intent(in) :: this integer, intent(in) :: c !column index integer, intent(in) :: j !level index real(r8), intent(in) :: s !relative saturation, [0, 1] real(r8), intent(in) :: imped !ice impedance type(soilstate_type), intent(in) :: soilstate_inst real(r8), intent(out):: hk !hydraulic conductivity [mm/s] real(r8), optional, intent(out):: dhkds !d[hk]/ds [mm/s] end subroutine soil_hk_interface subroutine soil_suction_interface(this, c, j, s, soilstate_inst, & smp, dsmpds) ! !DESCRIPTION: ! Compute soil suction potential ! ! !USES: use shr_kind_mod , only : r8 => shr_kind_r8 use SoilStateType , only : soilstate_type import :: soil_water_retention_curve_type ! ! !ARGUMENTS: class(soil_water_retention_curve_type), intent(in) :: this integer, intent(in) :: c !column index integer, intent(in) :: j !level index real(r8), intent(in) :: s !relative saturation, [0, 1] type(soilstate_type), intent(in) :: soilstate_inst real(r8), intent(out) :: smp !soil suction, negative, [mm] real(r8), optional, intent(out) :: dsmpds !d[smp]/ds, [mm] end subroutine soil_suction_interface subroutine soil_suction_inverse_interface(this, c, j, smp_target, & soilstate_inst, s_target) ! !DESCRIPTION: ! Compute relative saturation at which soil suction is equal to a target value. ! This is done by inverting the soil_suction equation to solve for s. ! ! !USES: use shr_kind_mod , only : r8 => shr_kind_r8 use SoilStateType , only : soilstate_type import :: soil_water_retention_curve_type ! ! !ARGUMENTS: class(soil_water_retention_curve_type), intent(in) :: this integer, intent(in) :: c !column index integer, intent(in) :: j !level index real(r8), intent(in) :: smp_target ! target soil suction, negative [mm] type(soilstate_type), intent(in) :: soilstate_inst real(r8) , intent(out) :: s_target ! relative saturation at which smp = smp_target [0,1] end subroutine soil_suction_inverse_interface end interface end module SoilWaterRetentionCurveMod