prepare for initial_value without default of 0

src/builtin/scale.F90

@@ -14,7 +14,7 @@ module fabm_builtin_scale
       real(rk)                        :: weight = 1.0_rk
       real(rk)                        :: offset = 0.0_rk
       character(len=attribute_length) :: units         = ''
-      real(rk)                        :: missing_value = -2.e20_rk
+      real(rk)                        :: missing_value = default_missing_value
       logical                         :: act_as_state_variable = .false.
       logical                         :: include_background = .false.
       integer                         :: result_output = output_instantaneous

src/builtin/sum.F90

@@ -33,7 +33,7 @@ module fabm_builtin_sum
       character(len=attribute_length) :: units         = ''
       integer                         :: result_output = output_instantaneous
       real(rk)                        :: offset        = 0.0_rk
-      real(rk)                        :: missing_value = -2.e20_rk
+      real(rk)                        :: missing_value = default_missing_value
       logical                         :: act_as_state_variable = .false.
       type (type_link), pointer       :: result_link => null()
 

src/builtin/time_filter.F90

@@ -15,7 +15,7 @@ module fabm_builtin_time_filter
    type, extends(type_global_model) :: type_interior_temporal_mean
       real(rk) :: window   ! Time period to average over (s)
       integer  :: n
-      real(rk) :: missing_value = -2.e20_rk
+      real(rk) :: missing_value = default_missing_value
       logical  :: use_incomplete_result = .false.
 
       type (type_global_interior_dependency_id) :: source
@@ -32,7 +32,7 @@ module fabm_builtin_time_filter
    type, extends(type_global_model) :: type_horizontal_temporal_mean
       real(rk) :: window   ! Time period to average over (s)
       integer  :: n
-      real(rk) :: missing_value = -2.e20_rk
+      real(rk) :: missing_value = default_missing_value
       logical  :: use_incomplete_result = .false.
 
       type (type_global_horizontal_dependency_id) :: source
@@ -56,9 +56,9 @@ module fabm_builtin_time_filter
    !end type
 
    type, extends(type_global_model) :: type_horizontal_temporal_maximum
-      real(rk) :: window                     ! Time window to compute running maximum over (s)
-      integer  :: n                          ! Number of bins to use to cover the period
-      real(rk) :: missing_value = -2.e20_rk  ! Missing value to use until the simulation has covered the window size [period]
+      real(rk) :: window                                 ! Time window to compute running maximum over (s)
+      integer  :: n                                      ! Number of bins to use to cover the period
+      real(rk) :: missing_value = default_missing_value  ! Missing value to use until the simulation has covered the window size [period]
 
       type (type_global_horizontal_dependency_id) :: source
       type (type_global_horizontal_variable_id) :: maximum
@@ -83,7 +83,7 @@ subroutine interior_temporal_mean_initialize(self, configunit)
       if (self%user_created) then
          call self%get_parameter(self%window, 'window', 's', 'window size')
          call self%get_parameter(self%n, 'n', '', 'number of bins')
-         call self%get_parameter(self%missing_value, 'missing_value', '', 'missing value to until the full window size has been covered', default=-2e20_rk)
+         call self%get_parameter(self%missing_value, 'missing_value', '', 'missing value to use until the full window size has been covered', default=default_missing_value)
       end if
 
       !call self%register_dependency(self%id_input, 'source', '', 'variable for which to compute running mean')
@@ -124,7 +124,7 @@ subroutine horizontal_temporal_mean_initialize(self, configunit)
       if (self%user_created) then
          call self%get_parameter(self%window, 'window', 's', 'window size')
          call self%get_parameter(self%n, 'n', '', 'number of bins')
-         call self%get_parameter(self%missing_value, 'missing_value', '', 'missing value to use until the full window size has been covered', default=-2e20_rk)
+         call self%get_parameter(self%missing_value, 'missing_value', '', 'missing value to use until the full window size has been covered', default=default_missing_value)
       end if
 
       !call self%register_dependency(self%id_input, 'source', '', 'variable for which to compute running mean')
@@ -164,7 +164,7 @@ subroutine horizontal_temporal_mean_initialize(self, configunit)
    !
    !   call self%get_parameter(self%window, 'window', 's', 'window size')
    !   call self%get_parameter(self%n, 'n', '', 'number of bins')
-   !   call self%get_parameter(self%missing_value, 'missing_value', '', 'missing value to use until the full window size has been covered', default=-2e20_rk)
+   !   call self%get_parameter(self%missing_value, 'missing_value', '', 'missing value to use until the full window size has been covered', default=default_missing_value)
    !
    !   call self%register_dependency(self%id_input, 'source', '', 'variable for which to compute running mean')
    !   call self%register_diagnostic_variable(self%id_output, 'mean',  '', 'running mean')
@@ -180,7 +180,7 @@ subroutine horizontal_temporal_maximum_initialize(self, configunit)
       if (self%user_created) then
          call self%get_parameter(self%window, 'window', 's', 'window size')
          call self%get_parameter(self%n, 'n', '', 'number of bins')
-         call self%get_parameter(self%missing_value, 'missing_value', '', 'missing value to use until the full window size has been covered', default=-2e20_rk)
+         call self%get_parameter(self%missing_value, 'missing_value', '', 'missing value to use until the full window size has been covered', default=default_missing_value)
       end if
 
       !call self%register_dependency(self%id_input, 'source', '', 'variable for which to compute running maximum')

src/fabm_coupling.F90

@@ -125,7 +125,7 @@ recursive subroutine get_initial_state(self, require_initialization)
          if (link%target%minimum /= -1.e20_rk) minimum = link%target%minimum
          if (link%target%maximum /=  1.e20_rk) maximum = link%target%maximum
          if (index(link%name, '/') == 0 .and. link%target%source == source_state .and. link%target%presence == presence_internal) then
-            if (require_initialization) then
+            if (require_initialization .or. link%target%initial_value == default_missing_value) then
                link%target%initial_value = self%initialization%get_real(trim(link%name), trim(link%target%long_name), &
                   trim(link%target%units), minimum=minimum, maximum=maximum)
             else

src/fabm_expressions.F90

@@ -18,7 +18,7 @@ module fabm_expressions
    type, extends(type_interior_expression) :: type_interior_temporal_mean_expression
       real(rk) :: period   ! Time period to average over (s)
       integer  :: n
-      real(rk) :: missing_value = -2.e20_rk
+      real(rk) :: missing_value = default_missing_value
       logical  :: use_incomplete_result = .false.
 
       type (type_link), pointer :: source => null()
@@ -38,9 +38,9 @@ module fabm_expressions
    end type
 
    type, extends(type_horizontal_expression) :: type_horizontal_temporal_maximum_expression
-      real(rk) :: period                     ! Time window to compute running maximum over (s)
-      integer  :: n                          ! Number of bins to use to cover the period
-      real(rk) :: missing_value = -2.e20_rk  ! Missing value to use until the simulation has covered the window size [period]
+      real(rk) :: period                                 ! Time window to compute running maximum over (s)
+      integer  :: n                                      ! Number of bins to use to cover the period
+      real(rk) :: missing_value = default_missing_value  ! Missing value to use until the simulation has covered the window size [period]
 
       type (type_link), pointer :: source => null()
    contains

src/fabm_types.F90

@@ -136,6 +136,8 @@ module fabm_types
    integer, parameter, public :: dependency_flag_none  = 0, &
                                  dependency_flag_stale = 1
 
+   real(rk), parameter, public :: default_missing_value = -2.e20_rk
+
    ! --------------------------------------------------------------------------
    ! Data types for pointers to variable values
    ! --------------------------------------------------------------------------
@@ -362,9 +364,9 @@ module fabm_types
       character(len=attribute_length) :: units          = ''
       real(rk)                        :: minimum        = -1.e20_rk
       real(rk)                        :: maximum        =  1.e20_rk
-      real(rk)                        :: missing_value  = -2.e20_rk
-      real(rk)                        :: prefill_value  = -2.e20_rk
-      real(rk)                        :: initial_value  = 0.0_rk
+      real(rk)                        :: missing_value  = default_missing_value
+      real(rk)                        :: prefill_value  = default_missing_value
+      real(rk)                        :: initial_value  = default_missing_value
       integer                         :: output         = output_instantaneous
       integer                         :: presence       = presence_internal
       integer                         :: domain         = domain_interior
@@ -1954,11 +1956,15 @@ subroutine add_variable(self, variable, name, units, long_name, missing_value, m
       if (present(minimum))       variable%minimum       = minimum
       if (present(maximum))       variable%maximum       = maximum
       if (present(missing_value)) variable%missing_value = missing_value
-      if (present(initial_value)) variable%initial_value = initial_value
       if (present(presence))      variable%presence      = presence
       if (present(act_as_state_variable)) variable%fake_state_variable = act_as_state_variable
       if (present(output))        variable%output        = output
       if (present(source))        variable%source        = source
+      if (present(initial_value)) then
+         variable%initial_value = initial_value
+      elseif (variable%source == source_state .and. variable%presence == presence_internal) then
+         variable%initial_value = 0.0_rk
+      end if
       variable%prefill_value = variable%missing_value
       if (present(fill_value)) then
          variable%prefill = prefill_constant
@@ -1979,7 +1985,8 @@ subroutine add_variable(self, variable, name, units, long_name, missing_value, m
          end select
       end if
 
-      if (present(state_index)) then
+      if (present(state_index)) call variable%state_indices%append(state_index)
+      if (variable%initial_value /= default_missing_value) then
          ! Ensure that initial value falls within prescribed valid range.
          if (variable%initial_value < variable%minimum .or. variable%initial_value > variable%maximum) then
             write (text,*) 'Initial value', variable%initial_value, 'for variable "' // trim(name) // '" lies&

testcases/fabm-selma-domcast.yaml

@@ -157,6 +157,9 @@ instances:
       dd: 0.0                      # detritus (mmol N/m3)
       o2: 180.0                    # oxygen (mmol O2/m3)
       po: 3.0                      # phosphate (mmol P/m3)
+      fl: 0.0                      # fluff (mmol N/m2)
+      pb: 0.0                      # PFe_s (mmol P/m2)
+      pw: 0.0                      # PFe_w (mmol P/m3)
   ammonium_input:
     model: constant_surface_flux
     parameters:

testcases/fabm-selma.yaml

@@ -130,6 +130,9 @@ instances:
       dd: 0.0                      # detritus (mmol N/m3)
       o2: 280.0                    # oxygen (mmol O2/m3)
       po: 4.0                      # phosphate (mmol P/m3)
+      fl: 0.0                      # fluff (mmol N/m2)
+      pb: 0.0                      # PFe_s (mmol P/m2)
+      pw: 0.0                      # PFe_w (mmol P/m3)
   ammonium_input:
     model: constant_surface_flux
     parameters: