irrigation.F90

Go to the documentation of this file.

!> @file
!>  Contains a single module, \ref irrigation, which
!>  provides support for estimating irrigation amounts
 
!> Provides support for assessing the effect of irrigation on recharge
!> values by estimating the irrigation required to maintain soil moisture levels
!> for specific crop types.
module irrigation
 
  use iso_c_binding, only          : c_short, c_int, c_float, c_double
  use constants_and_conversions
  use data_catalog, only           : dat
  use data_catalog_entry, only     : data_catalog_entry_t
  use datetime, only               : mmdd2doy
  use exceptions, only             : warn, die, assert
  use logfiles, only               : logs, log_all
  use parameters, only             : params
  use simulation_datetime, only    : sim_dt
  use fstring, only                : ascharacter, operator( .contains. )
  use fstring_list, only            : fstring_list_t
 
  implicit none
 
  private
 
  public :: irrigation__initialize, irrigation__calculate, irrigation__output_schedule_values
 
  enum, bind(c)
    enumerator :: app_none=0, app_field_capacity, app_defined_deficit, app_constant_amount, &
                  app_hwb_demand_based
  end enum
 
  character (len=35), parameter :: app_option_name(0:4) = &
     [ "Apply nothing                      ", &
       "Apply to field capacity            ", &
       "Apply to specified deficit fraction", &
       "Apply constant amount              ", &
       "Apply proportional to (PE + RO - R)"   ]
 
  real (c_float), allocatable     :: maximum_allowable_depletion_fraction(:)
  real (c_float), allocatable     :: irrigation_from_groundwater(:)
  real (c_float), allocatable     :: irrigation_from_surface_water(:)
 
  real (c_float), allocatable     :: fraction_of_irrigation_from_gw(:)
  real (c_float), allocatable     :: irrigation_efficiency(:)
  integer (c_int), allocatable    :: num_days_of_irrigation(:)
  integer (c_int), allocatable    :: first_day_of_irrigation(:)
  integer (c_int), allocatable    :: last_day_of_irrigation(:)
  integer (c_int), allocatable    :: application_method_code(:)
  integer (c_short), allocatable  :: monthly_irrigation_schedule(:,:)
  real (c_float), allocatable     :: application_amount(:)
 
contains
 
!> Estimate the irrigation water required to sustain plant growth.
!!
!! Estimate the irrigation water required in order to
!! keep soil moisture values above the maximum allowable depletion (MAD)
!! for each gridcell.
!!
!! @param[inout] pGrd Pointer to the model grid object
!! @param[in] pConfig Pointer to the configuration data structure (type T_CONFIG).
!!
 
  subroutine irrigation__initialize( is_active)
 
    logical (c_bool), intent(in)    :: is_active(:,:)
 
    ! [ LOCALS ]
    type (fstring_list_t)              :: sl_temp_list
    integer (c_int)              :: number_of_landuse_codes
    integer (c_int), allocatable :: landuse_table_codes(:)
    integer (c_int)              :: num_records
    logical (c_bool)             :: are_lengths_unequal
    integer (c_int)              :: index
    integer (c_int)              :: i
    integer (c_int)              :: status
    character (len=256)               :: str_buffer
    type (fstring_list_t)              :: sl_irrigation_days
    type (fstring_list_t)              :: sl_irrigation_begin
    type (fstring_list_t)              :: sl_irrigation_end
    type (fstring_list_t)              :: sl_application_method
    type (fstring_list_t)              :: sl_monthly_irrigation_schedule
    character (len=31)                :: temp_str
 
    allocate( irrigation_from_groundwater( count( is_active ) ), stat=status )
    call assert( status==0, "Failed to allocate memory.", __file__, __line__ )
 
    allocate( irrigation_from_surface_water( count( is_active ) ), stat=status )
    call assert( status==0, "Failed to allocate memory.", __file__, __line__ )
 
    ! create list of possible table headings to look for...
    call sl_temp_list%append( "LU_Code" )
    call sl_temp_list%append( "Landuse_Lookup_Code" )
 
    !> determine how many landuse codes are present
    call params%get_parameters( slkeys=sl_temp_list, ivalues=landuse_table_codes )
    number_of_landuse_codes = count( landuse_table_codes >= 0 )
 
    ! create list of possible table headings to look for...
    call sl_temp_list%clear()
    call sl_temp_list%append( "Monthly_Irrigation_Schedule" )
    call sl_temp_list%append( "Monthly_Irr_Schedule" )
    call sl_temp_list%append( "Irrigation_Application_Schedule" )
    call sl_temp_list%append( "Monthly_Application_Schedule" )
 
    !> determine how many landuse codes are present
    call params%get_parameters( slkeys=sl_temp_list, slvalues=sl_monthly_irrigation_schedule )
 
    !> retrieve list of fraction of irrigation from groundwater
    call sl_temp_list%clear()
    call sl_temp_list%append("Fraction_irrigation_from_GW")
    call sl_temp_list%append("Frac_irr_fm_GW")
    call sl_temp_list%append("Fraction_irrigation_from_groundwater")
    call sl_temp_list%append("Frac_irrigation_from_GW")
    call sl_temp_list%append("Fraction_of_irrigation_from_GW")
    call sl_temp_list%append("Fraction_of_irrigation_from_groundwater")
 
    call params%get_parameters( slkeys=sl_temp_list, fvalues=fraction_of_irrigation_from_gw, lfatal=true )
 
    !> retrieve maximum allowable depletion
    call sl_temp_list%clear()
    call sl_temp_list%append("Max_allowable_depletion")
    call sl_temp_list%append("Maximum_allowable_depletion")
    call sl_temp_list%append("MAD")
 
    call params%get_parameters( slkeys=sl_temp_list,                            &
                                fvalues=maximum_allowable_depletion_fraction,   &
                                lfatal=true )
 
 
    !> retrieve length (in days since planting) of irrigation
    call sl_temp_list%clear()
    call sl_temp_list%append("Irrigation_length")
    call sl_temp_list%append("Irrigation_days")
    call sl_temp_list%append("Irrigation_days_since_planting")
 
    call params%get_parameters( slkeys=sl_temp_list, slvalues=sl_irrigation_days, lfatal=false )
 
 
    !> retrieve first day of irrigation
    call sl_temp_list%clear()
    call sl_temp_list%append("First_day_of_irrigation")
    call sl_temp_list%append("First_DOY_irrigation")
    call sl_temp_list%append("Irrigation_start")
    call sl_temp_list%append("Irrigation_start_date")
 
    call params%get_parameters( slkeys=sl_temp_list, slvalues=sl_irrigation_begin, lfatal=true )
 
 
    !> retrieve last day of irrigation
    call sl_temp_list%clear()
    call sl_temp_list%append("Last_day_of_irrigation")
    call sl_temp_list%append("Last_DOY_irrigation")
    call sl_temp_list%append("Irrigation_end")
    call sl_temp_list%append("Irrigation_end_date")
 
    call params%get_parameters( slkeys=sl_temp_list, slvalues=sl_irrigation_end, lfatal=true )
    call sl_temp_list%clear()
 
 
    !> retrieve irrigation efficiency
    call sl_temp_list%clear()
    call sl_temp_list%append("Irrigation_efficiency")
    call sl_temp_list%append("Irrigation_application_efficiency")
 
    call params%get_parameters( slkeys=sl_temp_list,                     &
                                fvalues=irrigation_efficiency,           &
                                lfatal=true )
 
    !> check: number of irrigation efficiency values == number of landuse codes?
    num_records = ubound(irrigation_efficiency,1)
    are_lengths_unequal = ( num_records /= number_of_landuse_codes )
 
    if ( are_lengths_unequal )                                                             &
      call warn( smessage="The number of values specifying irrigation application"         &
        //" efficiency ("                                                                  &
        //ascharacter( num_records )//") does not match the number of landuse values ("    &
        //ascharacter( number_of_landuse_codes )//").",                                    &
        smodule=__file__, iline=__line__, lfatal=.true._c_bool )
 
 
    !> process first day of irrigation. retrieved as a list of strings;
    !! must convert the strings from mm/dd to DOY
    allocate( first_day_of_irrigation( sl_irrigation_begin%count ), stat=status )
    call assert( status==0, "Problem allocating memory.", __file__, __line__ )
 
    ! if there are no missing values in the column of data, process the days/dates
    if ( sl_irrigation_begin%count_matching("<NA>") == 0 ) then
 
      do index = 1, sl_irrigation_begin%count
        str_buffer = sl_irrigation_begin%get( index )
        if ( scan(str_buffer, "/-") /= 0 ) then
          first_day_of_irrigation( index ) = mmdd2doy( str_buffer, "FIRST_DAY_OF_IRRIGATION" )
        else
          first_day_of_irrigation( index ) = asint( str_buffer )
        endif
      enddo
 
    !> check: number of irrigation_start values == number of landuse codes?
      num_records = ubound(first_day_of_irrigation,1)
      are_lengths_unequal = ( num_records /= number_of_landuse_codes )
  
      if ( are_lengths_unequal )                                                             &
        call warn( smessage="The number of values specifying first day of irrigation ("      &
          //ascharacter( num_records )//") does not match the number of landuse values ("    &
          //ascharacter( number_of_landuse_codes )//").",                                    &
          smodule=__file__, iline=__line__, lfatal=.true._c_bool )
 
    else
 
      ! assign a dummy value and kill the run
      first_day_of_irrigation = 90
      call warn("No value was found to define the first day of irrigation "          &
              //"('first_day_of_irrigation' or 'irrigation_start').",                &
           shints="Make sure there is a lookup table with the column name "          &
           //"'first_day_of_irrigation' or 'irrigation_start'.", lfatal=true )
    endif
 
    !> process last day of irrigation. retrieved as a list of strings;
    !! must convert the strings from mm/dd to DOY
    allocate( last_day_of_irrigation( sl_irrigation_end%count ), stat=status )
    call assert( status==0, "Problem allocating memory.", __file__, __line__ )
 
    if ( sl_irrigation_end%count_matching("<NA>") == 0 ) then
 
      do index = 1, sl_irrigation_end%count
        str_buffer = sl_irrigation_end%get( index )
        if ( scan(str_buffer, "/-") /= 0 ) then
          last_day_of_irrigation( index ) = mmdd2doy( str_buffer, "LAST_DAY_OF_IRRIGATION" )
        else
          last_day_of_irrigation( index ) = asint( str_buffer )
        endif
      enddo
 
    !> check: number of irrigation_end values == number of landuse codes?
      num_records = ubound(last_day_of_irrigation,1)
      are_lengths_unequal = ( num_records /= number_of_landuse_codes )
  
      if ( are_lengths_unequal )                                                             &
        call warn( smessage="The number of values specifying last day of irrigation ("       &
          //ascharacter( num_records )//") does not match the number of landuse values ("    &
          //ascharacter( number_of_landuse_codes )//").",                                    &
          smodule=__file__, iline=__line__, lfatal=.true._c_bool )
 
    else
 
      last_day_of_irrigation = 90
      call warn("No value was found to define the last day of irrigation "        &
              //"('last_day_of_irrigation' or 'irrigation_end').",                &
           shints="Make sure there is a lookup table with the column name "       &
           //"'last_day_of_irrigation' or 'irrigation_end'.", lfatal=true )
    endif
 
    !> process number of days of irrigation. retrieved as a list of strings
    allocate( num_days_of_irrigation( sl_irrigation_days%count ), stat=status )
    call assert( status==0, "Problem allocating memory.", __file__, __line__ )
 
    num_days_of_irrigation = sl_irrigation_days%get_integer()
 
    if ( sl_irrigation_days%count_matching("<NA>") == 0 ) then
 
    !> check: number of 'Irrigation_length' values == number of landuse codes?
      num_records = ubound(num_days_of_irrigation,1)
      are_lengths_unequal = ( num_records /= number_of_landuse_codes )
 
      if ( are_lengths_unequal )                                                             &
        call warn( smessage="The number of values specifying 'irrigation_length' ("          &
          //ascharacter( num_records )//") does not match the number of landuse values ("    &
          //ascharacter( number_of_landuse_codes )//").",                                    &
          smodule=__file__, iline=__line__, lfatal=.true._c_bool )
 
    else
 
      num_days_of_irrigation = 999999
 
      call warn("No value was found to define the maximum number of days of irrigation ('irrigation_length').",   &
           shints="Make sure there is a lookup table with the column name "                                       &
           //"'irrigation_length'.", lfatal=true )
 
    endif
 
    !> retrieve application option (i.e. to field capacity, to defined deficit amount, as constant amount)
    call sl_temp_list%clear()
    call sl_temp_list%append("Irrigation_application_method")
    call sl_temp_list%append("Irrigation_application_scheme")
    call sl_temp_list%append("Irrigation_application_option")
    call sl_temp_list%append("Application_method")
    call sl_temp_list%append("Application_scheme")
    call sl_temp_list%append("Application_option")
 
    call params%get_parameters( slkeys=sl_temp_list, slvalues=sl_application_method, lfatal=true )
    call sl_temp_list%clear()
 
    allocate( application_method_code( sl_application_method%count ), stat=status )
    call assert( status==0, "Problem allocating memory.", __file__, __line__ )
 
    !> retrieve application amount. not used if "field capacity" option is active.
    !! value represents deficit fraction or constant amount depending on application option active.
    call sl_temp_list%clear()
    call sl_temp_list%append("Application_amount")
    call sl_temp_list%append("Irrigation_amount")
 
    call params%get_parameters( slkeys=sl_temp_list, fvalues=application_amount, lfatal=true )
    call sl_temp_list%clear()
 
    !> basic checks to see whether the number of parameters equals the number of lu codes
    num_records = ubound(first_day_of_irrigation,1)
    are_lengths_unequal = ( num_records /= number_of_landuse_codes )
 
    if ( are_lengths_unequal )                                                            &
      call warn( smessage="The number of values specifying date of first "                &
        //"irrigation application ("                                                      &
        //ascharacter( num_records )//") does not match the number of landuse values ("   &
        //ascharacter( number_of_landuse_codes )//").",                                   &
        smodule=__file__, iline=__line__, lfatal=.true._c_bool )
 
    num_records = ubound(last_day_of_irrigation,1)
    are_lengths_unequal = ( num_records /= number_of_landuse_codes )
 
    if ( are_lengths_unequal )                                                            &
      call warn( smessage="The number of values specifying date of last irrigation"       &
        //" application ("                                                                &
        //ascharacter( num_records )//") does not match the number of landuse values ("   &
        //ascharacter( number_of_landuse_codes )//").",                                   &
        smodule=__file__, iline=__line__, lfatal=.true._c_bool )
 
    num_records = ubound(fraction_of_irrigation_from_gw,1)
    are_lengths_unequal = ( num_records /= number_of_landuse_codes )
 
    if ( are_lengths_unequal )                                                            &
      call warn( smessage="The number of values specifying the fraction of irrigation"    &
        //" from groundwater ("                                                           &
        //ascharacter( num_records )//") does not match the number of landuse values ("   &
        //ascharacter( number_of_landuse_codes )//").",                                   &
        smodule=__file__, iline=__line__, lfatal=.true._c_bool )
 
    num_records = ubound(maximum_allowable_depletion_fraction,1)
    are_lengths_unequal = ( num_records /= number_of_landuse_codes )
 
    if ( are_lengths_unequal )                                                            &
      call warn( smessage="The number of values for the maximum allowable depletion "     &
        //" fraction ("                                                                   &
        //ascharacter( num_records )//") does not match the number of landuse values ("   &
        //ascharacter( number_of_landuse_codes )//").",                                   &
        smodule=__file__, iline=__line__, lfatal=.true._c_bool )
 
 
    num_records = sl_monthly_irrigation_schedule%count
    are_lengths_unequal = ( num_records /= number_of_landuse_codes )
 
    allocate( monthly_irrigation_schedule( number_of_landuse_codes, 31 ), stat=status )
    call assert( status==0, "Problem allocating memory")
 
    if ( are_lengths_unequal ) then
      call warn( smessage="The number of values defining monthly irrigation application"  &
        //" timing ("//ascharacter( num_records )//")~does not match the number of"       &
        //" landuse codes ("//ascharacter( number_of_landuse_codes )//"). ~Assuming"      &
        //" that irrigation is applied *every* day [default].",                           &
        smodule=__file__, iline=__line__, lecho=.true._c_bool, iloglevel=log_all )
 
      monthly_irrigation_schedule = 1_c_int
 
    else
 
      monthly_irrigation_schedule = 0_c_int
 
      do index=1, number_of_landuse_codes
        temp_str = sl_monthly_irrigation_schedule%get( index )
        if ( is_numeric( temp_str ) ) then
          do i=1, ubound(monthly_irrigation_schedule, 2)
            monthly_irrigation_schedule( index, i ) = int(asint( temp_str(i:i) ), c_short)
          enddo
        endif
      enddo
    endif
 
    num_records = ubound(application_method_code,1)
    are_lengths_unequal = ( num_records /= number_of_landuse_codes )
 
    if ( are_lengths_unequal )                                                            &
      call warn( smessage="The number of values for the irrigation application option ("  &
        //ascharacter( num_records )//") does not match the number of landuse values ("   &
        //ascharacter( number_of_landuse_codes )//").",                                   &
        smodule=__file__, iline=__line__, lfatal=.true._c_bool )
 
 
    num_records = ubound(application_amount,1)
    are_lengths_unequal = ( num_records /= number_of_landuse_codes )
 
    if ( are_lengths_unequal )                                                            &
      call warn( smessage="The number of values for the irrigation application amount ("  &
        //ascharacter( num_records )//") does not match the number of landuse values ("   &
        //ascharacter( number_of_landuse_codes )//").",                                   &
        smodule=__file__, iline=__line__, lfatal=.true._c_bool )
 
   ! locate the data structure associated with the gridded irrigation mask entries
    ! pIRRIGATION_MASK => DAT%find("IRRIGATION_MASK")
    ! if ( associated(pIRRIGATION_MASK) ) call pIRRIGATION_MASK%getvalues( )
 
    ! if ( associated(pIRRIGATION_MASK) ) then
 
    !   irrigation_mask = pack( real(pIRRIGATION_MASK%pGrdBase%iData, c_float), is_active )
 
    ! else
 
    !   irrigation_mask = 1.0_c_float
 
    ! endif
 
    call logs%write(" ## Initializing irrigation application rules and application schedules ##", ilinesbefore=1, &
      ilinesafter=1, iloglevel=log_all )
 
    do index = 1, sl_application_method%count
 
      str_buffer = sl_application_method%get( index )
 
      if ( str_buffer .contains. "capacity") then
        application_method_code( index ) = app_field_capacity
      elseif ( str_buffer .contains. "deficit") then
        application_method_code( index ) = app_defined_deficit
      elseif ( str_buffer .contains. "constant") then
        application_method_code( index ) = app_constant_amount
      elseif ( str_buffer .contains. "demand") then
        application_method_code( index ) = app_hwb_demand_based
      else
        application_method_code( index ) = app_none
      endif
 
 
      call logs%write("  landuse "//ascharacter( landuse_table_codes( index ) )//": " &
        //trim(app_option_name( application_method_code( index ) ) ), iloglevel=log_all )
 
    enddo
 
    irrigation_from_groundwater(:)    = 0.0_c_float
    irrigation_from_surface_water(:)  = 0.0_c_float
 
  end subroutine irrigation__initialize
 
!--------------------------------------------------------------------------------------------------
 
  function irrigation__output_schedule_values( landuse_index )  result( values )
 
    integer (c_int), intent(in)   :: landuse_index
    integer (c_int)               :: values(31)
 
    values = monthly_irrigation_schedule( landuse_index, : )
 
  end function irrigation__output_schedule_values
 
!--------------------------------------------------------------------------------------------------
 
  impure elemental subroutine irrigation__calculate( irrigation_amount,     &
                                              landuse_index,                &
                                              soil_storage,                 &
                                              soil_storage_max,             &
                                              total_available_water,        &
                                              rainfall,                     &
                                              runoff,                       &
                                              crop_etc,                     &
                                              irrigation_mask,              &
                                              num_days_since_planting,      &
                                              monthly_rainfall,             &
                                              monthly_runoff                &
                                                )
 
    real (c_float), intent(inout)          :: irrigation_amount
    integer (c_int), intent(in)            :: landuse_index
    real (c_double), intent(in)            :: soil_storage
    real (c_float), intent(in)             :: soil_storage_max
    real (c_double), intent(in)            :: total_available_water
    real (c_float), intent(in)             :: rainfall
    real (c_float), intent(in)             :: runoff
    real (c_float), intent(in)             :: crop_etc
    real (c_float), intent(in)             :: irrigation_mask
    integer (c_int), intent(in)            :: num_days_since_planting
    real (c_float), intent(in), optional   :: monthly_rainfall
    real (c_float), intent(in), optional   :: monthly_runoff
 
    ! [ LOCALS ]
    real (c_float)        :: depletion_fraction
 
    integer (c_int)       :: month
    integer (c_int)       :: day
    integer (c_int)       :: year
    integer (c_int)       :: julian_day
    integer (c_int)       :: day_of_year
    integer (c_int)       :: days_in_month
    integer (c_int)       :: num_days_from_origin
    integer (c_int)       :: irrigation_days_per_month
    real (c_float)        :: efficiency
    real (c_float)        :: interim_irrigation_amount
    integer (c_int)       :: option
 
    ! zero out Irrigation term
!    IRRIGATION_FROM_GROUNDWATER = rZERO
!    IRRIGATION_FROM_SURFACE_WATER = rZERO
 
    associate( dt => sim_dt%curr )
 
      julian_day = dt%getJulianDay()
      month = asint( dt%iMonth )
      day = asint( dt%iDay )
      year = dt%iYear
      days_in_month = sim_dt%iDaysInMonth
      day_of_year = sim_dt%iDOY
      num_days_from_origin = sim_dt%iNumDaysFromOrigin
 
    end associate
 
!     call pIRRIGATION_MASK%getvalues( month, day, year, julian_day )
!     iIrrigation_Mask = pack( pIRRIGATION_MASK%pGrdBase%iData, is_active )
 
    ! for each cell, add water if soil storage zone is below the
    ! maximum allowable depletion
 
    ! now we run the gauntlet of tests to ensure that we really need
    ! to perform all of the irrigation calculations
 
    do
 
      irrigation_amount         = 0.0_c_float
      interim_irrigation_amount = 0.0_c_float
      depletion_fraction        = 0.0_c_float
 
      if ( ( day_of_year < first_day_of_irrigation( landuse_index ) ) &
        .or. ( day_of_year > last_day_of_irrigation( landuse_index ) ) )  exit
 
!      if ( MAXIMUM_ALLOWABLE_DEPLETION_FRACTION( landuse_index ) > 0.99 )  exit
      if ( soil_storage_max <= 0.0_c_float ) exit
      if ( irrigation_mask < 1.0e-6_c_float ) exit
      if ( num_days_since_planting > num_days_of_irrigation( landuse_index ) ) exit
 
      ! total_available_water is calculated only by the fao56_two_stage module, but
      ! not by any other modules; need to just calculate depletion fraction based on
      ! total soil moisture storage capacity in this case
      if ( total_available_water > 0.0_c_float ) then
        depletion_fraction = real(min( ( soil_storage_max - soil_storage ) / total_available_water, 1.0_c_double ), c_float)
      else
        depletion_fraction = real(min( ( soil_storage_max - soil_storage ) / soil_storage_max, 1.0_c_double ), c_float)
      endif
 
      option = application_method_code( landuse_index )
 
      select case ( option )
 
        case ( app_field_capacity )
 
          if ( depletion_fraction >= maximum_allowable_depletion_fraction( landuse_index ) )      &
            interim_irrigation_amount = real(max( 0.0_c_double, real(soil_storage_max, c_double) - soil_storage ), c_float)
 
        case ( app_defined_deficit )
 
          ! @TODO check this calculation
 
          if ( depletion_fraction >= maximum_allowable_depletion_fraction( landuse_index ) )      &
            interim_irrigation_amount = real(max( 0.0_c_double, real(application_amount( landuse_index ), c_double)     &
                                        * soil_storage_max - soil_storage ), c_float)
 
        case ( app_constant_amount )
 
          if ( depletion_fraction >= maximum_allowable_depletion_fraction( landuse_index ) )      &
            interim_irrigation_amount = application_amount( landuse_index )
 
        case ( app_hwb_demand_based )
 
          if ( monthly_irrigation_schedule( landuse_index, day ) == 0 ) exit
 
          if (present( monthly_runoff ) .and. present( monthly_rainfall ) ) then
 
            irrigation_days_per_month = count( monthly_irrigation_schedule( landuse_index, 1:days_in_month ) == 1 )
 
            if ( irrigation_days_per_month <= 0 ) then
              interim_irrigation_amount = 0.0_c_float
            else
              interim_irrigation_amount = max( 0.0_c_float,    &
              ( crop_etc * real( days_in_month, c_float) + monthly_runoff - monthly_rainfall ) )  &
                / real( irrigation_days_per_month, c_float )
            endif
 
          else
 
            interim_irrigation_amount = max( 0.0_c_float, crop_etc + runoff - rainfall )
 
          endif
 
        case default
 
          interim_irrigation_amount = 0.0_c_float
 
      end select
 
      efficiency = max( irrigation_efficiency( landuse_index ), 0.20_c_float )
 
      irrigation_amount =  interim_irrigation_amount                                    &
                                     * irrigation_mask                                  &
                                     / efficiency
 
      exit
 
    enddo
 
  end subroutine irrigation__calculate
 
end module irrigation