model_iterate_multiple_simulations.F90

Go to the documentation of this file.

module model_iterate_multiple_simulations
 
  use iso_c_binding, only             : c_bool, c_float, c_int, c_double
  use constants_and_conversions, only : true, bnds, true
  use datetime, only                  : months
  use daily_calculation, only         : perform_daily_calculation
  use file_operations, only           : ascii_file_t
  use grid
  use logfiles, only                  : logs, log_all
  use model_domain, only              : model_domain_t
  use simulation_datetime, only       : sim_dt
  use fstring, only                   : ascharacter
  use output, only                    : write_output,                          &
                                        initialize_output,                     &
                                        initialize_multiple_sim_output,        &
                                        write_multi_sim_output,                &
                                        outspecs, ncdf_net_infiltration,       &
                                        ncdf_actual_et
 
!  use summary_statistics, only        : perform_polygon_summarize
  use grid
  implicit none
 
  private
 
  public :: iterate_over_multiple_simulation_days
 
  real (c_float), allocatable   :: monthly_net_infiltration_stats(:,:)
  real (c_float), allocatable   :: annual_net_infiltration_stats(:)
  real (c_float), allocatable   :: monthly_actual_et_stats(:,:)
  real (c_float), allocatable   :: annual_actual_et_stats(:)
  real (c_float), allocatable   :: monthly_rainfall_stats(:,:)
  real (c_float), allocatable   :: annual_rainfall_stats(:)
  integer (c_int)               :: day_count_by_month(12)
 
  real (c_double), target, allocatable   :: soil_moisture_storage_per_sim(:,:)
  real (c_float), target, allocatable    :: snow_storage_per_sim(:,:)
  real (c_double), target, allocatable   :: surface_storage_per_sim(:,:)
  real (c_float), target, allocatable    :: interception_storage_per_sim(:,:)
  real (c_float), target, allocatable    :: net_infiltration_per_sim(:,:)
  real (c_double), target, allocatable   :: actual_et_per_sim(:,:)
  real (c_float), target, allocatable    :: fog_per_sim(:,:)
 
! Concept: remap pointers to key state variables for each of X simulations,
!          run the daily simulation given current landuse, soil type, etc.
!          update rainfall by means of method of fragments
!
contains
 
  subroutine allocate_space_for_simulation_storage_state_variables(cells, number_of_simulations)
 
    class(model_domain_t), intent(inout)     :: cells
    integer (c_int), intent(in)          :: number_of_simulations
 
    ! [ LOCALS ]
    integer (c_int) :: length
    integer (c_int) :: indx
 
    length = size( cells%soil_storage, 1)
 
    allocate( soil_moisture_storage_per_sim(length, number_of_simulations))
    allocate( snow_storage_per_sim(length, number_of_simulations))
    allocate( surface_storage_per_sim(length, number_of_simulations))
    allocate( interception_storage_per_sim(length, number_of_simulations))
    allocate( net_infiltration_per_sim(length, number_of_simulations))
    allocate( actual_et_per_sim(length, number_of_simulations))
    allocate( fog_per_sim(length, number_of_simulations))
 
    allocate( monthly_net_infiltration_stats(length, 12) )
    allocate( annual_net_infiltration_stats(length) )
    allocate( monthly_actual_et_stats(length, 12) )
    allocate( annual_actual_et_stats(length) )
    allocate( monthly_rainfall_stats(length, 12) )
    allocate( annual_rainfall_stats(length) )
 
    ! do not want or need this memory since we are going to swap out a
    ! different set of arrays for each simulation number
    if (associated(cells%snow_storage)) then
      do indx=1,number_of_simulations
        snow_storage_per_sim(:,indx) = cells%snow_storage
      enddo
      deallocate(cells%snow_storage)
    endif
 
    if (associated(cells%soil_storage)) then
      do indx=1,number_of_simulations
        soil_moisture_storage_per_sim(:,indx) = cells%soil_storage
      enddo
      deallocate(cells%soil_storage)
    endif
 
    if (associated(cells%surface_storage)) then
      do indx=1,number_of_simulations
        surface_storage_per_sim(:,indx) = cells%surface_storage
      enddo
      deallocate(cells%surface_storage)
    endif
 
    if (associated(cells%interception_storage)) then
      do indx=1,number_of_simulations
        interception_storage_per_sim(:,indx) = cells%interception_storage
      enddo
      deallocate(cells%interception_storage)
    endif
 
    if (associated(cells%net_infiltration)) then
      do indx=1,number_of_simulations
        net_infiltration_per_sim(:,indx) = cells%net_infiltration
      enddo
      deallocate(cells%net_infiltration)
    endif
 
    if (associated(cells%actual_et)) then
      do indx=1,number_of_simulations
        actual_et_per_sim(:,indx) = cells%actual_et
      enddo
      deallocate(cells%actual_et)
    endif
 
    if (associated(cells%fog)) then
      do indx=1,number_of_simulations
        fog_per_sim(:,indx) = cells%fog
      enddo
      deallocate(cells%fog)
    endif
 
  end subroutine allocate_space_for_simulation_storage_state_variables
 
!------------------------------------------------------------------------------------------------
 
  subroutine iterate_over_multiple_simulation_days(cells, number_of_simulations)
 
    use precipitation__method_of_fragments, only  : simulation_number
 
    class(model_domain_t), intent(inout)     :: cells
    integer (c_int), intent(inout)       :: number_of_simulations
 
    ! [ LOCALS ]
    integer (c_int) :: sim_number
 
    ! set flags in output mod to allow multiple simulation output to be generated
    outspecs(ncdf_net_infiltration)%multisim_outputs = true
    outspecs(ncdf_actual_et)%multisim_outputs = true
 
    call allocate_space_for_simulation_storage_state_variables(cells, number_of_simulations)
 
    call reset_annual_accumulators()
    call reset_monthly_accumulators()
 
    !call initialize_multiple_sim_output(cells, number_of_simulations)
 
    do while ( sim_dt%curr <= sim_dt%end )
 
      call cells%update_landuse_codes()
 
      do sim_number=1,number_of_simulations
 
        ! modifying module variable from precipitation__method_of_fragments
        simulation_number = sim_number
 
        call cells%get_weather_data( )
 
        if (sim_number==1) then
          call logs%write("Calculating: "//sim_dt%curr%prettydate(),  &
                          iloglevel=log_all, lecho=.true._c_bool )
          write(*,"(a,i0,a)", advance="no") "  running ",number_of_simulations, &
                                            " simulations: "
        endif
 
        write(*,fmt="(a)", advance="no") "."
 
        cells%snow_storage => snow_storage_per_sim(:,sim_number)
        cells%soil_storage => soil_moisture_storage_per_sim(:,sim_number)
        cells%interception_storage => interception_storage_per_sim(:,sim_number)
        cells%surface_storage => surface_storage_per_sim(:,sim_number)
        cells%net_infiltration => net_infiltration_per_sim(:,sim_number)
        cells%actual_et => actual_et_per_sim(:,sim_number)
        cells%fog => fog_per_sim(:,sim_number)
 
        call perform_daily_calculation( cells )
 
        call write_output( cells )
        call update_accumulators( cells, sim_number )
!        call write_multi_sim_output( cells, sim_number)
  !      call perform_polygon_summarize( cells )
 
        call cells%dump_variables( )
 
      enddo
 
      write(*,fmt="(/)")
 
      call sim_dt%addDay( )
 
    enddo
 
    call finalize_accumulators( cells, number_of_simulations )
 
  end subroutine iterate_over_multiple_simulation_days
 
!------------------------------------------------------------------------------------------------
 
  subroutine reset_monthly_accumulators( )
 
    monthly_actual_et_stats = 0.0_c_float
    monthly_rainfall_stats = 0.0_c_float
    monthly_net_infiltration_stats = 0.0_c_float
    day_count_by_month(:) = 0
 
  end subroutine reset_monthly_accumulators
 
!------------------------------------------------------------------------------------------------
 
  subroutine reset_annual_accumulators( )
 
    annual_actual_et_stats = 0.0_c_float
    annual_rainfall_stats = 0.0_c_float
    annual_net_infiltration_stats = 0.0_c_float
 
  end subroutine reset_annual_accumulators
 
!------------------------------------------------------------------------------------------------
 
  subroutine update_accumulators( cells, simulation_number )
 
    class(model_domain_t), intent(inout)     :: cells
    integer (c_int), intent(in)          :: simulation_number
 
    ![ LOCALS ]
    integer (c_int)  :: month
 
    month = sim_dt%curr%iMonth
 
    if (simulation_number == 1)                                                &
      day_count_by_month(month) = day_count_by_month(month) + 1
 
    ! called each day of a simulation for nsim number of simulations
    monthly_net_infiltration_stats(:,month) = monthly_net_infiltration_stats(:,month)    &
                                               + cells%net_infiltration
 
    monthly_actual_et_stats(:,month) = monthly_actual_et_stats(:,month)    &
                                               + real(cells%actual_et, c_float)
 
    monthly_rainfall_stats(:,month) = monthly_rainfall_stats(:,month)    &
                                               + cells%rainfall
 
    ! ANNUAL_NET_INFILTRATION_STATS(:,simulation_number) =                             &
    !    ANNUAL_NET_INFILTRATION_STATS(:,simulation_number) + cells%net_infiltration
    !
    ! ANNUAL_ACTUAL_ET_STATS(:,simulation_number) =                                    &
    !    ANNUAL_ACTUAL_ET_STATS(:,simulation_number) + cells%actual_et
 
  end subroutine update_accumulators
 
!------------------------------------------------------------------------------------------------
 
  subroutine finalize_accumulators(cells, number_of_simulations)
 
    class(model_domain_t), intent(inout)     :: cells
    integer (c_int), intent(in)          :: number_of_simulations
 
    ![ LOCALS ]
    real (c_float)   :: number_of_simulation_days
    integer (c_int)  :: month
    character (len=256)   :: filename, file_suffix
    integer (c_int)  :: start_year, end_year
    integer (c_int)  :: nx, ny
    character (len=3)     :: month_abbrev
 
    type (GENERAL_GRID_T), pointer  :: pTempGrid
 
    start_year = sim_dt%start%iYear
    end_year = sim_dt%end%iYear
    nx = cells%number_of_columns
    ny = cells%number_of_rows
 
    file_suffix = "__"//trim(ascharacter(number_of_simulations))//"-simulations__"              &
                  //trim(ascharacter(ny))//"_cols_by_"//trim(ascharacter(nx))//"_rows__"        &
                  //trim(ascharacter(start_year))//"_to_"//trim(ascharacter(end_year))//".asc"
 
    ptempgrid => grid_create( inx=cells%number_of_columns, iny=cells%number_of_rows, &
        rx0=cells%X_ll, ry0=cells%Y_ll, &
        rgridcellsize=cells%gridcellsize, idatatype=grid_datatype_real )
 
    call grid_set_nodata_value(ptempgrid, fvalue=cells%nodata_fill_value(1,1))
 
    number_of_simulation_days = real( sim_dt%end - sim_dt%start + 1.0, c_float)
 
    do month=1,12
 
      month_abbrev = months(month)%sName
 
      annual_net_infiltration_stats(:) = annual_net_infiltration_stats(:)            &
                                         + monthly_net_infiltration_stats(:,month)
 
      annual_actual_et_stats(:) = annual_actual_et_stats(:)                          &
                                  + monthly_actual_et_stats(:,month)
 
      annual_rainfall_stats(:) = annual_rainfall_stats(:)                            &
                                  + monthly_rainfall_stats(:,month)
 
      monthly_net_infiltration_stats(:,month) = monthly_net_infiltration_stats(:,month)          &
                                                / real(number_of_simulations, c_float)      &
                                                * real(months(month)%iNumDays, c_float)     &
                                                / real(day_count_by_month(month), c_float)
 
      monthly_actual_et_stats(:,month) = monthly_actual_et_stats(:,month)                  &
                                          / real(number_of_simulations, c_float)      &
                                          * real(months(month)%iNumDays, c_float)     &
                                          / real(day_count_by_month(month), c_float)
 
      monthly_rainfall_stats(:,month) = monthly_rainfall_stats(:,month)                    &
                                          / real(number_of_simulations, c_float)      &
                                          * real(months(month)%iNumDays, c_float)     &
                                          / real(day_count_by_month(month), c_float)
 
      ptempgrid%rData = unpack( monthly_actual_et_stats(:,month), cells%active, cells%nodata_fill_value )
      filename = "MEAN_MONTHLY_SUM-"//trim(month_abbrev)//"__actual_evapotranspiration"//trim(file_suffix)
      call grid_writearcgrid( sfilename=filename, pgrd=ptempgrid )
 
      ptempgrid%rData = unpack( monthly_net_infiltration_stats(:,month), cells%active, cells%nodata_fill_value )
      filename = "MEAN_MONTHLY_SUM-"//trim(month_abbrev)//"__net_infiltration"//trim(file_suffix)
      call grid_writearcgrid( sfilename=filename, pgrd=ptempgrid )
 
      ptempgrid%rData = unpack( monthly_rainfall_stats(:,month), cells%active, cells%nodata_fill_value )
      filename = "MEAN_MONTHLY_SUM-"//trim(month_abbrev)//"__rainfall"//trim(file_suffix)
      call grid_writearcgrid( sfilename=filename, pgrd=ptempgrid )
 
     enddo
 
     annual_net_infiltration_stats(:) = annual_net_infiltration_stats(:)                   &
                                         / real(number_of_simulations, c_float)       &
                                         * 365.0_c_float                                   &
                                         / real(number_of_simulation_days, c_float)
 
     annual_actual_et_stats(:) = annual_actual_et_stats(:)                         &
                                 / real(number_of_simulations, c_float)       &
                                 * 365.0_c_float                                   &
                                 / real(number_of_simulation_days, c_float)
 
     annual_rainfall_stats(:) = annual_rainfall_stats(:)                           &
                                 / real(number_of_simulations, c_float)       &
                                 * 365.0_c_float                                   &
                                 / real(number_of_simulation_days, c_float)
 
     ptempgrid%rData = unpack( annual_actual_et_stats, cells%active, cells%nodata_fill_value )
     filename = "MEAN_ANNUAL_SUM__actual_evapotranspiration"//trim(file_suffix)
     call grid_writearcgrid( sfilename=filename, pgrd=ptempgrid )
 
     ptempgrid%rData = unpack( annual_net_infiltration_stats, cells%active, cells%nodata_fill_value )
     filename = "MEAN_ANNUAL_SUM__net_infiltration"//trim(file_suffix)
     call grid_writearcgrid( sfilename=filename, pgrd=ptempgrid )
 
     ptempgrid%rData = unpack( annual_rainfall_stats, cells%active, cells%nodata_fill_value )
     filename = "MEAN_ANNUAL_SUM__rainfall"//trim(file_suffix)
     call grid_writearcgrid( sfilename=filename, pgrd=ptempgrid )
 
     call grid_destroy( ptempgrid )
 
  end subroutine finalize_accumulators
 
 
end module model_iterate_multiple_simulations