block_reader.f90

!This file is part of Notus 0.5.0

!Copyright Bordeaux-INP, Université de Bordeaux, CNRS
!
!Contributors:
!Antoine Lemoine, 19-10-2016, antoine.lemoine@bordeaux-inp.fr

!This software is a computer program whose purpose is to simulate fluid flows.

!This software is governed by the CeCILL license under French law and
!abiding by the rules of distribution of free software.  You can  use,
!modify and/ or redistribute the software under the terms of the CeCILL
!license as circulated by CEA, CNRS and INRIA at the following URL
!"http://www.cecill.info".

!As a counterpart to the access to the source code and  rights to copy,
!modify and redistribute granted by the license, users are provided only
!with a limited warranty  and the software's author,  the holder of the
!economic rights,  and the successive licensors  have only  limited
!liability.

!In this respect, the user's attention is drawn to the risks associated
!with loading,  using,  modifying and/or developing or reproducing the
!software by the user in light of its specific status of free software,
!that may mean  that it is complicated to manipulate,  and  that  also
!therefore means  that it is reserved for developers  and  experienced
!professionals having in-depth computer knowledge. Users are therefore
!encouraged to load and test the software's suitability as regards their
!requirements in conditions enabling the security of their systems and/or
!data to be ensured and,  more generally, to use and operate it in the
!same conditions as regards security.

!The fact that you are presently reading this means that you have had
!knowledge of the CeCILL license and that you accept its terms.

module mod_ui_parse_system
   use mod_nts_language
   use mod_nts_parse_block
   use mod_nts_parse_path
   use mod_ui_read_solver
   use mod_ui_system_state
   implicit none

contains

   logical recursive function ui_parse_system(parser, tok, keyword_id) result(keyword_id_found)
      use enum_test_case
      use variables_checkpoint_restart
      use variables_core
      use variables_output, only : output_directory, case_directory
      use variables_test_case, only : test_case, test_case_switch
      use variables_cpu_time

      type(t_parser) :: parser
      type(t_token), intent(in) :: tok
      integer, intent(in) :: keyword_id

      type(t_token) :: tok_brace, tok_test_case
      type(t_token) :: tok_next

      keyword_id_found = .true.

      select case(keyword_id)
      case(kw_output_directory)
         output_directory = simplify_path(case_directory//'/'//nts_evaluate_string_expression(parser))
         call nts_expect(parser, tk_semicolon)

      case(kw_measure_cpu_time)
         is_cpu_time_measuring = .true.
         call nts_expect(parser, tk_semicolon)

      case(kw_measure_time_iteration_cpu_time)
         is_cpu_time_time_iteration_measuring = .true.
         call nts_expect(parser, tk_semicolon)

      case(kw_write_cpu_time)
         is_cpu_time_writing = .true.
         call nts_expect(parser, tk_semicolon)

      case(kw_enable_checkpoint)
         is_checkpoint = nts_evaluate_boolean_expression(parser)
         call nts_expect(parser, tk_semicolon)

      case(kw_checkpoint_frequency)
         checkpoint_frequency = nts_evaluate_integer_expression(parser)
         call nts_expect(parser, tk_semicolon)

      case(kw_checkpoint_metric)
         call nts_get_keyword(parser, tok_next)

         select case(tok_next%keyword_id)
         case(kw_cpu_time)
            checkpoint_metric = checkpoint_metric_cpu_time
         case(kw_time_iteration)
            checkpoint_metric = checkpoint_metric_time_iteration
         case default
            call parser%throw_error(tok, "checkpoint_metric expect 'checkpoint_metric_cpu_time' or 'checkpoint_metric_time_iteration'")
         end select

      case(kw_enable_initial_conditions_checkpoint)
         is_initial_conditions_checkpoint = nts_evaluate_boolean_expression(parser)
         call nts_expect(parser, tk_semicolon)

      case(kw_enable_last_iteration_checkpoint)
         is_last_iteration_checkpoint = nts_evaluate_boolean_expression(parser)
         call nts_expect(parser, tk_semicolon)

      case(kw_checkpoint_max_files)
         checkpoint_n_files = nts_evaluate_integer_expression(parser)
         call nts_expect(parser, tk_semicolon)

         if (checkpoint_n_files < 2) call parser%throw_error(tok, "'checkpoint_max_files' must be ≥ 2")

      case(kw_checkpoint_name)
         checkpoint_filename = nts_evaluate_string_expression(parser)
         call nts_expect(parser, tk_semicolon)

         ui_is_checkpoint_file_read = .true.

      case(kw_restart)
         restart_filename = nts_parse_path(parser)
         call nts_expect(parser, tk_semicolon)

         is_restart = .true.

      case(kw_test_case)
         call nts_peek(parser, tok_test_case)

         if (.not. nts_next_token(parser, tk_keyword)) then
            call parser%throw_error(tok, "test case keyword expected (ie. tc_poiseuille) but got a '"// &
               trim(token_id_to_string(tok_test_case%kind))//"' instead")
         end if

         select case(tok_test_case%keyword_id)
         case(kw_tc_channel_3d)
            test_case = test_case_channel_3d
         case(kw_tc_backward_facing_step_axisymmetric)
            test_case = test_case_ibm_backward_facing_step_axisymmetric
         case(kw_tc_lagrangian_particles)
            test_case = test_case_lagrangian_particles
         case(kw_tc_linear_system_test)
            test_case = test_case_linear_system_test
            call nts_peek(parser, tok_brace)
            call nts_expect(parser, tk_left_brace)
            call parser%new_scope(tok_brace)
            call nts_parse_block(parser, ui_test_case_linear_system_test)
         case(kw_tc_species_transport)
            test_case = test_case_species_transport
         case(kw_tc_plane_turbulent_channel)
            test_case = test_case_plane_turbulent_channel
         case(kw_tc_poiseuille_rayleigh_benard)
            test_case = test_case_poiseuille_rayleigh_benard
         case(kw_tc_poiseuille_viscosity)
            test_case = test_case_poiseuille_viscosity
         case(kw_tc_solitary_wave_periodic)
            test_case = test_case_solitary_wave_periodic
         case(kw_tc_solitary_wave_wall)
            test_case = test_case_solitary_wave_wall
         case(kw_tc_standing_wave)
            test_case = test_case_standing_wave
         case(kw_tc_thermal_contact_resistance)
            test_case = test_case_thermal_contact_resistance
            test_case_switch = nts_evaluate_integer_expression(parser)
         case(kw_tc_bubble_rise)
            test_case = test_case_bubble_rise
         case(kw_tc_jet_buckling)
            test_case = test_case_jet_buckling
         case default
            call parser%throw_error(tok_test_case, "keyword '"//ui_keywords(tok_test_case%keyword_id)%name//&
               "' is not a valid test case keyword")
         end select

         call nts_expect(parser, tk_semicolon)

         is_test_case_mode = .true.

      case(kw_test_case_switch)
         test_case_switch = nts_evaluate_integer_expression(parser)

      case default
         call parser%throw_error(tok, "invalid keyword '"//parser%lex%keywords(tok%keyword_id)%name//"' in system block")
         keyword_id_found = .false.
      end select
   end function ui_parse_system

   ! This routine would be preferably be located with the corresponding test case.
   logical recursive function ui_test_case_linear_system_test(parser, tok, keyword_id) result(keyword_id_found)
      use variables_test_case_linear_system_test

      type(t_parser) :: parser
      type(t_token), intent(in) :: tok
      integer, intent(in) :: keyword_id

      character(len=:), allocatable :: stl_type

      keyword_id_found = .true.

      select case(keyword_id)
      case(kw_stencil_type)
         stl_type = nts_evaluate_string_expression(parser)
         select case (stl_type)
         case ("1_star")
            ls_test_stencil_type = stencil_1_star
         case ("1_square")
            ls_test_stencil_type = stencil_1_square
         case ("2_star")
            ls_test_stencil_type = stencil_2_star
         case ("2_square")
            ls_test_stencil_type = stencil_2_square
         case default
            call parser%throw_error(tok, "unknown stencil type: "//stl_type)
         end select
         call nts_expect(parser, tk_semicolon)

      case(kw_solver)
         call ui_read_solver(parser, ls_test_solver)

      case default
         keyword_id_found = .false.
      end select
   end function ui_test_case_linear_system_test

end module mod_ui_parse_system