RunControl.f90

Go to the documentation of this file.

module runcontrolmodule
  use kindmodule, only: i4b
  use simstagesmodule
  use virtualdatamanagermodule
  use mappermodule
  use listsmodule, only: basesolutionlist
  use numericalsolutionmodule, only: numericalsolutiontype
  use profilermodule
  implicit none
  private
 
  public :: create_seq_run_control
 
  type, public :: runcontroltype
    class(virtualdatamanagertype), pointer :: virtual_data_mgr !< syncs globally accessible data, timely, by
                                                               !! linking (local) or message passing (remote)
    type(mappertype) :: mapper !< a 'mapper' for copying data between two memory addresses
  contains
    procedure :: start => ctrl_start
    procedure :: at_stage => ctrl_at_stage
    procedure :: finish => ctrl_finish
    procedure :: after_con_cr => ctrl_after_con_cr
 
    ! private
    procedure, private :: init_handler
    procedure, private :: before_con_df
    procedure, private :: after_con_df
    procedure, private :: destroy
  end type runcontroltype
 
contains
 
  function create_seq_run_control() result(run_controller)
    class(runcontroltype), pointer :: run_controller
 
    allocate (run_controller)
 
  end function create_seq_run_control
 
  subroutine ctrl_start(this)
    class(runcontroltype) :: this
 
    allocate (this%virtual_data_mgr)
 
  end subroutine ctrl_start
 
  subroutine ctrl_finish(this)
    use simvariablesmodule, only: iout
    use memorymanagermodule, only: mem_write_usage, mem_da
    use timermodule, only: elapsed_time
    use simmodule, only: final_message
    class(runcontroltype) :: this
 
    ! clean up
    call this%destroy()
 
    ! -- Write memory usage, elapsed time and terminate
    call mem_write_usage(iout)
    call mem_da()
 
    ! stop and print timings
    call g_prof%stop(g_prof%tmr_finalize)
    call g_prof%stop(g_prof%tmr_run)
    call g_prof%print(iout)
    call g_prof%destroy()
 
    call elapsed_time(iout, 1)
    call final_message()
 
  end subroutine ctrl_finish
 
  !> @brief This will call the handler for a particular stage
  !< in the simulation run
  subroutine ctrl_at_stage(this, stage)
    class(runcontroltype) :: this
    integer(I4B) :: stage
 
    if (stage == stg_bfr_mdl_df) then
      call this%init_handler()
    else if (stage == stg_aft_con_cr) then
      call this%after_con_cr()
    else if (stage == stg_bfr_con_df) then
      call this%before_con_df()
    else if (stage == stg_aft_con_df) then
      call this%after_con_df()
    end if
 
    call this%virtual_data_mgr%synchronize(stage)
    call this%mapper%scatter(0, stage)
 
  end subroutine ctrl_at_stage
 
  subroutine init_handler(this)
    use simvariablesmodule, only: simulation_mode
    class(runcontroltype), target :: this
 
    call this%virtual_data_mgr%create(simulation_mode)
    call this%virtual_data_mgr%init()
    call this%mapper%init()
 
  end subroutine init_handler
 
  !> @brief Actions after connections have been created
  !<
  subroutine ctrl_after_con_cr(this)
    class(runcontroltype) :: this
 
    call this%virtual_data_mgr%activate_halo()
 
  end subroutine ctrl_after_con_cr
 
  !> @brief Actions before defining the connections
  !!
  !! Set up the virtual data manager:
  !! The models and exchanges in the halo for this interface
  !! have been determined. Add them to the virtual data manager
  !! for synchronization. (After which the interface model
  !< grids can be constructed)
  subroutine before_con_df(this)
    class(runcontroltype), target :: this
    ! local
    integer(I4B) :: i
    class(*), pointer :: obj_ptr
    class(numericalsolutiontype), pointer :: sol
 
    ! Add (halo) models and exchanges to the virtual
    ! solutions. Set the synchronization handler
    ! in the numerical solution.
    do i = 1, basesolutionlist%Count()
      obj_ptr => basesolutionlist%GetItem(i)
      select type (obj_ptr)
      class is (numericalsolutiontype)
        sol => obj_ptr
        call this%virtual_data_mgr%add_solution(sol)
        sol%synchronize => rc_solution_sync
        sol%synchronize_ctx => this
      end select
    end do
 
    ! The remote data fields in exchanges need to
    ! be copied in from the virtual exchanges
    call this%mapper%add_exchange_vars()
 
  end subroutine before_con_df
 
  !> @brief Actions after defining connections
  !<
  subroutine after_con_df(this)
    class(runcontroltype) :: this
 
    ! Reduce the halo
    call this%virtual_data_mgr%compress_halo()
 
    ! Add variables in interface models to the mapper
    call this%mapper%add_interface_vars()
 
  end subroutine after_con_df
 
  !> @brief Synchronizes from within numerical solution (delegate)
  !<
  subroutine rc_solution_sync(num_sol, stage, ctx)
    use numericalsolutionmodule, only: numericalsolutiontype
    class(numericalsolutiontype) :: num_sol
    integer(I4B) :: stage
    class(*), pointer :: ctx
 
    select type (ctx)
    class is (runcontroltype)
      call ctx%virtual_data_mgr%synchronize_sln(num_sol%id, stage)
      call ctx%mapper%scatter(num_sol%id, stage)
    end select
 
  end subroutine rc_solution_sync
 
  subroutine destroy(this)
    class(runcontroltype) :: this
 
    call this%virtual_data_mgr%destroy()
    deallocate (this%virtual_data_mgr)
 
  end subroutine destroy
 
end module runcontrolmodule