clarify naming

Author: juliasloan25

experiments/ClimaEarth/components/ocean/clima_seaice.jl

@@ -17,18 +17,18 @@ This type is used by the coupler to indicate that this simulation
 is an surface/ocean simulation for dispatch.
 
 It contains the following objects:
-- `sea_ice::SIM`: The ClimaSeaIce simulation object.
+- `ice::SIM`: The ClimaSeaIce simulation object.
 - `area_fraction::A`: A ClimaCore Field representing the surface area fraction of this component model on the exchange grid.
 - `melting_speed::MS`: An constant characteristic speed for melting/freezing.
 - `remapping::REMAP`: Objects needed to remap from the exchange (spectral) grid to Oceananigans spaces.
-- `ocean_sea_ice_fluxes::NT`: A NamedTuple of fluxes between the ocean and sea ice, computed at each coupling step.
+- `ocean_ice_fluxes::NT`: A NamedTuple of fluxes between the ocean and sea ice, computed at each coupling step.
 """
 struct ClimaSeaIceSimulation{SIM, A, MS, REMAP, NT} <: Interfacer.SeaIceModelSimulation
-    sea_ice::SIM
+    ice::SIM
     area_fraction::A
     melting_speed::MS
     remapping::REMAP
-    ocean_sea_ice_fluxes::NT
+    ocean_ice_fluxes::NT
 end
 
 """
@@ -51,14 +51,13 @@ can be found in the documentation for `ClimaOcean.ocean_simulation`.
 """
 function ClimaSeaIceSimulation(land_fraction, ocean; output_dir)
     # Initialize the sea ice with the same grid as the ocean
-    grid = ocean.ocean.model.grid
+    grid = ocean.ocean.model.grid # TODO can't use lat/lon grid at poles for ice
     arch = grid.architecture
     advection = ocean.ocean.model.advection.T
     top_heat_boundary_condition = CO.MeltingConstrainedFluxBalance()
 
     # TODO use branch ss-js/top-heat-bc for this constructor
-    sea_ice =
-        CO.sea_ice_simulation(grid, ocean.ocean; advection, top_heat_boundary_condition)
+    ice = CO.sea_ice_simulation(grid, ocean.ocean; advection, top_heat_boundary_condition)
 
     melting_speed = 1e-4
 
@@ -68,24 +67,24 @@ function ClimaSeaIceSimulation(land_fraction, ocean; output_dir)
     # Before version 0.96.22, the NetCDFWriter was broken on GPU
     if arch isa OC.CPU || pkgversion(OC) >= v"0.96.22"
         # Save all tracers and velocities to a NetCDF file at daily frequency
-        outputs = OC.prognostic_fields(sea_ice.model)
+        outputs = OC.prognostic_fields(ice.model)
         jld_writer = OC.JLDWriter(
-            sea_ice.model,
+            ice.model,
             outputs;
             schedule = OC.TimeInterval(86400), # Daily output
             filename = joinpath(output_dir, "seaice_diagnostics.jld2"),
             overwrite_existing = true,
             array_type = Array{Float32},
         )
-        sea_ice.output_writers[:diagnostics] = jld_writer
+        ice.output_writers[:diagnostics] = jld_writer
     end
 
     # Allocate space for the sea ice-ocean (io) fluxes
-    ocean_sea_ice_fluxes = ocean.ocean_sea_ice_fluxes
+    ocean_ice_fluxes = ocean.ocean_ice_fluxes
 
     # TODO clean this up
-    # Get the area fraction from the fractional sea ice concentration
-    area_fraction = sea_ice.model.ice_concentration
+    # Get the initial area fraction from the fractional ice concentration
+    area_fraction = ice.model.ice_concentration
 
     # Overwrite ice fraction with the static land area fraction anywhere we have nonzero land area
     #  max needed to avoid Float32 errors (see issue #271; Heisenbug on HPC)
@@ -97,16 +96,16 @@ function ClimaSeaIceSimulation(land_fraction, ocean; output_dir)
         max(min(area_fraction_boundary_space, FT(1) - land_fraction), FT(0))
 
     sim = ClimaSeaIceSimulation(
-        sea_ice,
+        ice,
         area_fraction_boundary_space,
         melting_speed,
         remapping,
-        ocean_sea_ice_fluxes,
+        ocean_ice_fluxes,
     )
     return sim
 end
 
-function update_sic!(area_fraction, sea_ice)
+function update_sic!(area_fraction, ice)
     # TODO
 end
 
@@ -116,11 +115,11 @@ end
 
 # Timestep the simulation forward to time `t`
 Interfacer.step!(sim::ClimaSeaIceSimulation, t) =
-    OC.time_step!(sim.sea_ice, float(t) - sim.sea_ice.model.clock.time)
+    OC.time_step!(sim.ice, float(t) - sim.ice.model.clock.time)
 
 Interfacer.get_field(sim::ClimaSeaIceSimulation, ::Val{:area_fraction}) = sim.area_fraction
-Interfacer.get_field(sim::ClimaSeaIceSimulation, Val(:sea_ice_concentration)) =
-    sim.sea_ice.model.ice_concentration
+Interfacer.get_field(sim::ClimaSeaIceSimulation, ::Val(:ice_concentration)) =
+    sim.ice.model.ice_concentration
 
 # At the moment, we return always Float32. This is because we always want to run
 # Oceananingans with Float64, so we have no way to know the float type here. Sticking with
@@ -139,8 +138,7 @@ Interfacer.get_field(sim::ClimaSeaIceSimulation, ::Val{:surface_diffuse_albedo})
 # Approximate the sea ice surface temperature as the temperature computed from the
 #  fluxes at the previous timestep.
 Interfacer.get_field(sim::ClimaSeaIceSimulation, ::Val{:surface_temperature}) =
-    273.15 .+
-    OC.interior(sim.sea_ice.model.ice_thermodynamics.top_surface_temperature, :, :, 1)
+    273.15 .+ OC.interior(sim.ice.model.ice_thermodynamics.top_surface_temperature, :, :, 1)
 
 """
     FluxCalculator.update_turbulent_fluxes!(sim::ClimaSeaIceSimulation, fields)
@@ -162,7 +160,7 @@ function FluxCalculator.update_turbulent_fluxes!(sim::ClimaSeaIceSimulation, fie
     # Only LatitudeLongitudeGrid are supported because otherwise we have to rotate the vectors
 
     (; F_lh, F_sh, F_turb_ρτxz, F_turb_ρτyz, F_turb_moisture) = fields
-    grid = sim.sea_ice.model.grid
+    grid = sim.ice.model.grid
 
     # Remap momentum fluxes onto reduced 2D Center, Center fields using scratch arrays and fields
     CC.Remapping.interpolate!(
@@ -184,8 +182,8 @@ function FluxCalculator.update_turbulent_fluxes!(sim::ClimaSeaIceSimulation, fie
 
     # Set the momentum flux BCs at the correct locations using the remapped scratch fields
     # Note that this requires the sea ice model to always be run with dynamics turned on
-    si_flux_u = sim.sea_ice.model.dynamics.external_stresses.top.u
-    si_flux_v = sim.sea_ice.model.dynamics.external_stresses.top.v
+    si_flux_u = sim.ice.model.dynamics.external_stresses.top.u
+    si_flux_v = sim.ice.model.dynamics.external_stresses.top.v
     set_from_extrinsic_vectors!(
         (; u = si_flux_u, v = si_flux_v),
         grid,
@@ -202,10 +200,10 @@ function FluxCalculator.update_turbulent_fluxes!(sim::ClimaSeaIceSimulation, fie
     remapped_F_sh = sim.remapping.scratch_arr2
 
     # Update the sea ice only where the concentration is greater than zero.
-    si_flux_heat = ice_sim.sea_ice.model.external_heat_fluxes.top
+    si_flux_heat = ice_sim.ice.model.external_heat_fluxes.top
     OC.interior(si_flux_heat, :, :, 1) .=
         OC.interior(si_flux_heat, :, :, 1) .+ (
-            (OC.interior(sim.sea_ice.model.ice_concentration, :, :, 1) .> 0) .*
+            (OC.interior(sim.ice.model.ice_concentration, :, :, 1) .> 0) .*
             (remapped_F_lh .+ remapped_F_sh)
         )
 
@@ -248,52 +246,50 @@ function FieldExchanger.update_sim!(sim::ClimaSeaIceSimulation, csf, area_fracti
     # Update only the part due to radiative fluxes. For the full update, the component due
     # to latent and sensible heat is missing and will be updated in update_turbulent_fluxes.
     # Update the sea ice only where the concentration is greater than zero.
-    si_flux_heat = sim.sea_ice.model.external_heat_fluxes.top
+    si_flux_heat = sim.ice.model.external_heat_fluxes.top
     OC.interior(si_flux_heat, :, :, 1) .=
-        (OC.interior(sim.sea_ice.model.ice_concentration, :, :, 1) .> 0) .*
-        remapped_F_radiative
+        (OC.interior(sim.ice.model.ice_concentration, :, :, 1) .> 0) .* remapped_F_radiative
 
     return nothing
 end
 
 """
     ocean_seaice_fluxes!(ocean_sim, ice_sim)
 
-Compute the fluxes between the ocean and sea ice, storing them in the `ocean_sea_ice_fluxes`
+Compute the fluxes between the ocean and sea ice, storing them in the `ocean_ice_fluxes`
 fields of the ocean and sea ice simulations.
 """
 function FluxCalculator.ocean_seaice_fluxes!(
     ocean_sim::OceananigansSimulation,
     ice_sim::ClimaSeaIceSimulation,
 )
-    # TODO unify sea_ice vs ice naming convention in this file
     melting_speed = ice_sim.melting_speed
     ocean_properties = ocean_sim.ocean_properties
 
     # Compute the fluxes and store them in the both simulations
     CO.compute_sea_ice_ocean_fluxes!(
-        ice_sim.ocean_sea_ice_fluxes,
+        ice_sim.ocean_ice_fluxes,
         ocean_sim.ocean,
-        ice_sim.sea_ice,
+        ice_sim.ice,
         melting_speed,
         ocean_properties,
     )
-    ocean_sim.ocean_sea_ice_fluxes = ice_sim.ocean_sea_ice_fluxes
+    ocean_sim.ocean_ice_fluxes = ice_sim.ocean_ice_fluxes
 
     ## Update the internals of the sea ice model
     # Set the bottom heat flux to the sum of the frazil and interface heat fluxes
-    bottom_heat_flux = ice_sim.sea_ice.model.external_heat_fluxes.bottom
+    bottom_heat_flux = ice_sim.ice.model.external_heat_fluxes.bottom
 
-    Qf = sea_ice_ocean_fluxes.frazil_heat        # frazil heat flux
-    Qi = sea_ice_ocean_fluxes.interface_heat     # interfacial heat flux
+    Qf = ice_sim.ocean_ice_fluxes.frazil_heat        # frazil heat flux
+    Qi = ice_sim.ocean_ice_fluxes.interface_heat     # interfacial heat flux
     bottom_heat_flux .= Qf .+ Qi
 
     ## Update the internals of the ocean model
     ρₒ⁻¹ = 1 / ocean_sim.ocean_properties.reference_density
     cₒ = ocean_sim.ocean_properties.heat_capacity
 
     Jᵀio = Qio * ρₒ⁻¹ / cₒ
-    Jˢio = sea_ice_ocean_fluxes.salt[i, j, 1] * ℵᵢ
+    Jˢio = ice_sim.ocean_ice_fluxes.salt[i, j, 1] * ℵᵢ
 
     # ℑxᶠᵃᵃ: interpolate faces to centers
     τxio = ρτxio[i, j, 1] * ρₒ⁻¹ * ℑxᶠᵃᵃ(i, j, 1, grid, ℵ)

experiments/ClimaEarth/components/ocean/oceananigans.jl

@@ -21,17 +21,17 @@ It contains the following objects:
 - `area_fraction::A`: A ClimaCore Field representing the surface area fraction of this component model on the exchange grid.
 - `ocean_properties::OPROP`: A NamedTuple of ocean properties and parameters
 - `remapping::REMAP`: Objects needed to remap from the exchange (spectral) grid to Oceananigans spaces.
-- `ocean_sea_ice_fluxes::NT`: A NamedTuple of fluxes between the ocean and sea ice, computed at each coupling step.
-- `sea_ice_concentration::SIC`: A ClimaCore Field representing the sea ice concentration on the ocean/sea ice grid.
+- `ocean_ice_fluxes::NT`: A NamedTuple of fluxes between the ocean and sea ice, computed at each coupling step.
+- `ice_concentration::SIC`: A ClimaCore Field representing the sea ice concentration on the ocean/sea ice grid.
 """
 struct OceananigansSimulation{SIM, A, OPROP, REMAP, NT, SIC} <:
        Interfacer.OceanModelSimulation
     ocean::SIM
     area_fraction::A
     ocean_properties::OPROP
     remapping::REMAP
-    ocean_sea_ice_fluxes::NT
-    sea_ice_concentration::SIC
+    ocean_ice_fluxes::NT
+    ice_concentration::SIC
 end
 
 """
@@ -199,7 +199,7 @@ function OceananigansSimulation(
     x_momentum = OC.Field{OC.Face, OC.Center, Nothing}(grid)
     y_momentum = OC.Field{OC.Center, OC.Face, Nothing}(grid)
 
-    ocean_sea_ice_fluxes = (
+    ocean_ice_fluxes = (
         interface_heat = io_bottom_heat_flux,
         frazil_heat = io_frazil_heat_flux,
         salt = io_salt_flux,
@@ -212,7 +212,7 @@ function OceananigansSimulation(
         area_fraction,
         ocean_properties,
         remapping,
-        ocean_sea_ice_fluxes,
+        ocean_ice_fluxes,
     )
     return sim
 end
@@ -326,8 +326,11 @@ function FluxCalculator.update_turbulent_fluxes!(sim::OceananigansSimulation, fi
         F_turb_ρτxz_cc,
         F_turb_ρτyz_cc,
     )
-    oc_flux_u .= (1 .- sea_ice_concentration) .* oc_flux_u
-    oc_flux_v .= (1 .- sea_ice_concentration) .* oc_flux_v
+
+    # Weight the ocean fluxes by (1 - ice concentration)
+    ice_concentration = OC.interior(sim.ice_concentration, :, :, 1)
+    oc_flux_u .= (1 .- ice_concentration) .* oc_flux_u
+    oc_flux_v .= (1 .- ice_concentration) .* oc_flux_v
 
     (; ocean_reference_density, ocean_heat_capacity, ocean_fresh_water_density) =
         sim.ocean_properties
@@ -346,7 +349,7 @@ function FluxCalculator.update_turbulent_fluxes!(sim::OceananigansSimulation, fi
     oc_flux_T = surface_flux(sim.ocean.model.tracers.T)
     OC.interior(oc_flux_T, :, :, 1) .=
         OC.interior(oc_flux_T, :, :, 1) .+
-        (1 .- sea_ice_concentration) .* (
+        (1 .- ice_concentration) .* (
             (remapped_F_lh .+ remapped_F_sh) ./
             (ocean_reference_density * ocean_heat_capacity)
         )
@@ -363,22 +366,22 @@ function FluxCalculator.update_turbulent_fluxes!(sim::OceananigansSimulation, fi
     surface_salinity = OC.interior(sim.ocean.model.tracers.S, :, :, 1)
     OC.interior(oc_flux_S, :, :, 1) .=
         OC.interior(oc_flux_S, :, :, 1) .-
-        (1 .- sea_ice_concentration) .* (surface_salinity .* moisture_fresh_water_flux)
+        (1 .- ice_concentration) .* (surface_salinity .* moisture_fresh_water_flux)
     return nothing
 end
 
 function Interfacer.update_field!(sim::OceananigansSimulation, ::Val{:area_fraction}, field)
     sim.area_fraction .= field
     return nothing
 end
-# Note, sea_ice_concentration is on the ocean/sea ice grid. This assumes the ocean and
+# Note, ice_concentration is on the ocean/sea ice grid. This assumes the ocean and
 #  sea ice are using the same grid.
 function Interfacer.update_field!(
     sim::OceananigansSimulation,
-    ::Val{:sea_ice_concentration},
+    ::Val{:ice_concentration},
     field,
 )
-    sim.sea_ice_concentration .= field
+    sim.ice_concentration .= field
     return nothing
 end
 
@@ -401,7 +404,7 @@ so a sign change is needed when we convert from precipitation to salinity flux.
 function FieldExchanger.update_sim!(sim::OceananigansSimulation, csf, area_fraction)
     (; ocean_reference_density, ocean_heat_capacity, ocean_fresh_water_density) =
         sim.ocean_properties
-    sea_ice_concentration = OC.interior(sim.sea_ice_concentration, :, :, 1)
+    ice_concentration = OC.interior(sim.ice_concentration, :, :, 1)
 
     # Remap radiative flux onto scratch array; rename for clarity
     CC.Remapping.interpolate!(
@@ -417,7 +420,7 @@ function FieldExchanger.update_sim!(sim::OceananigansSimulation, csf, area_fract
     # TODO document ordering of flux updates somewhere
     OC.interior(oc_flux_T, :, :, 1) .=
         OC.interior(oc_flux_T, :, :, 1) .+
-        (1 .- sea_ice_concentration) .*
+        (1 .- ice_concentration) .*
         (remapped_F_radiative ./ (ocean_reference_density * ocean_heat_capacity))
 
     # Remap precipitation fields onto scratch arrays; rename for clarity
@@ -442,7 +445,7 @@ function FieldExchanger.update_sim!(sim::OceananigansSimulation, csf, area_fract
         OC.interior(sim.ocean.model.tracers.S, :, :, 1) .* precipitating_fresh_water_flux
     OC.interior(oc_flux_S, :, :, 1) .=
         OC.interior(oc_flux_S, :, :, 1) .+
-        (1 .- sea_ice_concentration) .* .-surface_salinity_flux
+        (1 .- ice_concentration) .* .-surface_salinity_flux
     return nothing
 end
 

src/FieldExchanger.jl

@@ -39,13 +39,15 @@ function update_surface_fractions!(cs::Interfacer.CoupledSimulation)
     # ice and ocean fractions are dynamic
     if haskey(cs.model_sims, :ice_sim)
         ice_sim = cs.model_sims.ice_sim
-        Interfacer.get_field!(cs.fields.temp1, ice_sim, Val(:sea_ice_concentration)) # TODO extend for non-ClimaSeaIce, add to Interfacer
-        sea_ice_concentration = cs.fields.temp1
+        Interfacer.get_field!(cs.fields.temp1, ice_sim, Val(:ice_concentration)) # TODO extend for non-ClimaSeaIce, add to Interfacer
+
+        # TODO ice concentration needs to be binary
+        ice_concentration = cs.fields.temp1
         # max needed to avoid Float32 errors (see issue #271; Heisenbug on HPC)
         Interfacer.update_field!(
             ice_sim,
             Val(:area_fraction),
-            max.(min.(sea_ice_concentration, FT(1) .- land_fraction), FT(0)),
+            max.(min.(ice_concentration, FT(1) .- land_fraction), FT(0)),
         )
         ice_fraction = Interfacer.get_field(ice_sim, Val(:area_fraction))
     else
@@ -73,11 +75,7 @@ function update_surface_fractions!(cs::Interfacer.CoupledSimulation)
 
     if haskey(cs.model_sims, :ocean_sim) && haskey(cs.model_sims, :ice_sim)
         # TODO add this update_field to interfacer
-        Interfacer.update_field!(
-            ocean_sim,
-            Val(:sea_ice_concentration),
-            sea_ice_concentration,
-        )
+        Interfacer.update_field!(ocean_sim, Val(:ice_concentration), ice_concentration)
     end
 
     # check that the sum of area fractions is 1