Infer default soil BCs from process types

Author: bgroenks96

src/boundary_conditions.jl

@@ -14,6 +14,7 @@ is invoked recursively on the entry matching the name of `var`, if it exists. Ot
 returned.
 """
 get_field_boundary_conditions(::AbstractBoundaryConditions, grid::AbstractLandGrid) = (;)
+get_field_boundary_conditions(::Nothing, grid::AbstractLandGrid) = (;)
 get_field_boundary_conditions(bc::BoundaryCondition, ::AbstractLandGrid) = bc
 get_field_boundary_conditions(bcs::FieldBCs, ::AbstractLandGrid) = bcs
 
@@ -82,17 +83,17 @@ end
 
 # Convenience aliases for PrescribedBC
 NoFlux(progvar::Symbol) = PrescribedBC(progvar, NoFluxBoundaryCondition())
-PrescribedFlux(progvar::Symbol, value; kwargs...) = PrescribedBC(progvar, FluxBoundaryCondition(value; kwargs...))
-PrescribedValue(progvar::Symbol, value; kwargs...) = PrescribedBC(progvar, ValueBoundaryCondition(value; kwargs...))
-PrescribedGradient(progvar::Symbol, value; kwargs...) = PrescribedBC(progvar, GradientBoundaryCondition(value; kwargs...))
+PrescribedFlux(progvar::Symbol, condition; kwargs...) = PrescribedBC(progvar, FluxBoundaryCondition(condition; kwargs...))
+PrescribedValue(progvar::Symbol, condition; kwargs...) = PrescribedBC(progvar, ValueBoundaryCondition(condition; kwargs...))
+PrescribedGradient(progvar::Symbol, condition; kwargs...) = PrescribedBC(progvar, GradientBoundaryCondition(condition; kwargs...))
 
 """
 Implementation of `Oceananigans.BoundaryConditions.getbc` for `Input{name}` placeholders that retrieves the input `Field` from
-`state.inputs` and returns the value at the given index.
+`state` and returns the value at the given index.
 """
 @inline function getbc(::Input{name, units, <:XY}, i::Integer, j::Integer, grid::OceananigansGrids.AbstractGrid, clock, state) where {name, units}
-    input_field = getproperty(state.inputs, name)
-    return @inbounds input_field[i, j]
+    field = getproperty(state, name)
+    return @inbounds field[i, j]
 end
 
 """

src/models/models.jl

@@ -3,11 +3,16 @@
 export SoilModel
 include("soil/soil_model.jl")
 
-export SoilBoundaryConditions, SoilBC, GroundHeatFlux, GeothermalHeatFlux, FreeDrainage, ImpermeableBoundary
+export SoilBoundaryConditions, SoilBC
+export GroundHeatFlux, GeothermalHeatFlux, PrescribedTemperature
+export FreeDrainage, ImpermeableBoundary, InfiltrationFlux
 include("soil/soil_model_bcs.jl")
 
 include("soil/soil_model_init.jl")
 
+export CoupledSoilAtmosphereModel
+include("soil/soil_atmosphere_model.jl")
+
 # Vegetation
 
 export VegetationModel

src/models/soil/soil_model.jl

@@ -37,7 +37,7 @@ $(TYPEDFIELDS)
     constants::Constants = PhysicalConstants(eltype(grid))
 
     "Boundary conditions"
-    boundary_conditions::BoundaryConditions = SoilBoundaryConditions(eltype(grid))
+    boundary_conditions::BoundaryConditions = SoilBoundaryConditions(eltype(grid), energy, hydrology)
 
     "State variable initializer"
     initializer::Initializer = SoilInitializer()

src/models/soil/soil_model_bcs.jl

@@ -4,12 +4,12 @@
 Boundary condition type for soil models that provides boundary conditions for each
 of the relevant internal processes, i.e. energy, hydrology, ...
 """
-struct SoilBC{EnergyBC, WaterBC} <: AbstractBoundaryConditions
+@kwdef struct SoilBC{EnergyBC, WaterBC} <: AbstractBoundaryConditions
     "Boundary condition for the soil energy balance"
-    energy::EnergyBC
+    energy::EnergyBC = GroundHeatFlux()
 
     "Boundary condition for the soil water balance"
-    hydrology::WaterBC
+    hydrology::WaterBC = ImpermeableBoundary()
 end
 
 variables(bc::SoilBC) = tuplejoin(variables(bc.hydrology), variables(bc.energy))
@@ -19,23 +19,38 @@ function compute_auxiliary!(state, model, bc::SoilBC)
     compute_auxiliary!(state, model, bc.energy)
 end
 
+function compute_tendencies!(state, model, bc::SoilBC)
+    compute_tendencies!(state, model, bc.hydrology)
+    compute_tendencies!(state, model, bc.energy)
+end
+
 function get_field_boundary_conditions(bcs::SoilBC, grid::AbstractLandGrid)
     water_bc = get_field_boundary_conditions(bcs.hydrology, grid)
     energy_bc = get_field_boundary_conditions(bcs.energy, grid)
     return merge(water_bc, energy_bc)
 end
 
+# Energy BCs
+
 """
-Alias for `PrescribedFlux` with name `ground_heat_flux` representing the net ground heat flux at the soil surface.
+Alias for `PrescribedFlux` on `internal_energy` with name `ground_heat_flux` representing the net ground heat flux at the soil surface.
 """
 GroundHeatFlux(init=nothing) = PrescribedFlux(:internal_energy, Input(:ground_heat_flux, init, units=u"W/m^2"))
 
 """
-Alias for `PrescribedFlux` with name `Q_geo` representing the geothermal heat flux at the bottom
+Alias for `PrescribedFlux` on `internal_energy` with name `geothermal_heat_flux` representing the geothermal heat flux at the bottom
 boundary of the soil column.
 """
 GeothermalHeatFlux(init=nothing) = PrescribedFlux(:internal_energy, Input(:geothermal_heat_flux, init, units=u"W/m^2"))
 
+"""
+Alias for `PrescribedValue` on `temperature` with the given name.
+"""
+PrescribedTemperature(name::Symbol, init=nothing) = PrescribedValue(:temperature, Input(name, init, units=u"°C"))
+PrescribedTemperature(condition) = PrescribedValue(:temperature, condition)
+
+# Hydrology BCs
+
 """
 Alias for `PrescribedFlux` with name `infiltration` representing liquid water infiltration at the soil surface.
 """
@@ -52,10 +67,25 @@ column, thereby allowing free drainage of water.
 """
 FreeDrainage(::Type{NF}) where {NF} = PrescribedGradient(:pressure_head, zero(NF))
 
+# SoilBoundaryConditions constructor
+
 """
-Alias for `ColumnBoundaryConditions` with defaults suitable for `SoilModel`s.
+Creates `ColumnBoundaryConditions` with defaults suitable for the given soil process configurations.
 """
-SoilBoundaryConditions(::Type{NF}; top=default_soil_upperbc(NF), bottom=default_soil_lowerbc(NF)) where {NF} = ColumnBoundaryConditions(; top, bottom)
+SoilBoundaryConditions(
+    ::Type{NF},
+    energy::SoilEnergyBalance = SoilEnergyBalance(NF),
+    hydrology::SoilHydrology = SoilHydrology(NF);
+    top=SoilBC(energy = default_upperbc(energy), hydrology = default_upperbc(hydrology)),
+    bottom=SoilBC(energy = default_lowerbc(energy), hydrology = default_lowerbc(hydrology))
+) where {NF} = ColumnBoundaryConditions(; top, bottom)
+
+# Default boundary conditions for various soil process configurations
+
+default_upperbc(::SoilEnergyBalance) = GroundHeatFlux()
+default_upperbc(::SoilHydrology{NF, NoFlow}) where {NF} = nothing
+default_upperbc(::SoilHydrology) = InfiltrationFlux()
 
-default_soil_upperbc(::Type{NF}, energy=GroundHeatFlux(zero(NF)), hydrology=InfiltrationFlux(zero(NF))) where {NF} = SoilBC(energy, hydrology)
-default_soil_lowerbc(::Type{NF}, energy=GeothermalHeatFlux(zero(NF)), hydrology=ImpermeableBoundary()) where {NF} = SoilBC(energy, hydrology)
+default_lowerbc(::SoilEnergyBalance) = GeothermalHeatFlux()
+default_lowerbc(::SoilHydrology{NF, NoFlow}) where {NF} = nothing
+default_lowerbc(::SoilHydrology) = ImpermeableBoundary()

src/processes/abstract_types.jl

@@ -28,6 +28,10 @@ compute_auxiliary!(state, model, ::AbstractProcess) = nothing
 
 compute_tendencies!(state, model, ::AbstractProcess) = nothing
 
+# also allow dispatch on nothing
+compute_auxiliary!(state, model, ::Nothing) = nothing
+compute_tendencies!(state, model, ::Nothing) = nothing
+
 # Soil process types
 # TODO: Think more about these process types and what methods they should have.