commandline_parser.f

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!  The @header2, @begin_table, @item3 and @end_table commands are custom defined
!  commands in Doxygen.in. They are defined under ALIASES. For the page created
!  here, the 80 column limit is exceeded. Arguments of aliases are separated by
!  ','. If you intended ',' to be a string you must use an escaped comma '\,'.
!
!-------------------------------------------------------------------------------
!*******************************************************************************
!
!  Note separating the Doxygen comment block here so detailed decription is
!  found in the Module not the file.
!
!*******************************************************************************
 
      MODULE commandline_parser
      USE stel_kinds
      USE file_opts, only: path_length
      USE profiler
 
      IMPLICIT NONE
 
!*******************************************************************************
!  commandline parser module parameters
!*******************************************************************************
      INTEGER, PARAMETER, PRIVATE :: max_arg_length = 8
      INTEGER, PARAMETER, PRIVATE :: max_length = path_length                  &
     &                                          + max_arg_length + 1
 
!  Commandline parser error codes.
      INTEGER, PARAMETER :: commandline_parser_no_error      = 0
      INTEGER, PARAMETER :: commandline_parser_arg_not_found = -1
 
!*******************************************************************************
!  DERIVED-TYPE DECLARATIONS
!  1) commandline parser base class
!
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      TYPE commandline_parser_class
         CHARACTER (len=max_length) :: command
         CHARACTER (len=max_arg_length), DIMENSION(:), POINTER ::              &
     &      arg => null()
         CHARACTER (len=path_length), DIMENSION(:), POINTER ::                 &
     &      value => null()
      END TYPE
 
      CONTAINS
!*******************************************************************************
!  CONSTRUCTION SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION commandline_parser_construct()
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (commandline_parser_class), POINTER ::                              &
     &   commandline_parser_construct
 
!  local variables
      CHARACTER (len=max_length) :: temp
      INTEGER                    :: num_args, i, value_index
      REAL (rprec)               :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      temp = ''
      num_args = 0
      value_index = 0
      ALLOCATE(commandline_parser_construct)
 
!  Read the zeroith arg to get the number of arguments. This should also be the
!  command name.
      CALL getcarg(0, commandline_parser_construct%command, num_args)
 
      IF (num_args .le. 0) THEN
         CALL commandline_parser_print_help
      END IF
 
!  Allocate the arrays and
      ALLOCATE(commandline_parser_construct%arg(num_args))
      ALLOCATE(commandline_parser_construct%value(num_args))
 
!  Loop through the command line arguments, and setup the argument and value
!  arrays
      DO i = 1, num_args
         CALL getcarg(i, temp, num_args)
 
!  Check for a - as the first character.
         IF (temp(1:1) .eq. '-') THEN
            value_index = index(temp, '=')
            IF (value_index .eq. 0) THEN
!  Check for help command.
               IF (trim(temp) .eq. '-h') THEN
                  CALL commandline_parser_print_help
               END IF
 
               commandline_parser_construct%arg(i) = trim(temp)
               commandline_parser_construct%value(i) = ''
            ELSE
               commandline_parser_construct%arg(i) =                           &
     &            temp(1:value_index - 1)
               commandline_parser_construct%value(i) =                         &
     &            temp(value_index + 1:len_trim(temp))
            END IF
         ELSE
!  Implicity set the argument to -file
            commandline_parser_construct%arg(i) = '-file'
            commandline_parser_construct%value(i) =                            &
     &         temp(1:path_length)
         END IF
      END DO
 
      CALL profiler_set_stop_time('commandline_parser_construct',              &
     &                            start_time)
 
      END FUNCTION
 
!*******************************************************************************
!  DESTRUCTION SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE commandline_parser_destruct(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (commandline_parser_class), POINTER :: this
 
!  Start of executable code
      IF (ASSOCIATED(this%arg)) THEN
         DEALLOCATE(this%arg)
         this%arg => null()
      END IF
 
      IF (ASSOCIATED(this%value)) THEN
         DEALLOCATE(this%value)
         this%value => null()
      END IF
 
      DEALLOCATE(this)
 
      END SUBROUTINE
 
!*******************************************************************************
!  GETTER SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION commandline_parser_get_string(this, arg)
 
      IMPLICIT NONE
 
!  Declare Arguments
      CHARACTER (len=path_length) :: commandline_parser_get_string
      TYPE (commandline_parser_class), INTENT(in) :: this
      CHARACTER (len=*), INTENT(in)               :: arg
 
!  Local arguments
      INTEGER                                     :: i
      REAL (rprec)                                :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
!  Loop through the arguments until the correct arg is found.
      commandline_parser_get_string = ''
 
      IF (ASSOCIATED(this%arg)) THEN
         DO i = 1, SIZE(this%arg)
            IF (trim(this%arg(i)) .eq. trim(arg)) THEN
               commandline_parser_get_string = this%value(i)
 
               CALL profiler_set_stop_time(                                    &
     &                 'commandline_parser_get_string', start_time)
 
               RETURN
            END IF
         END DO
      END IF
 
      CALL profiler_set_stop_time('commandline_parser_get_string',             &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION commandline_parser_get_integer(this, arg,                       &
     &                                        default_value)
 
      IMPLICIT NONE
 
!  Declare Arguments
      INTEGER :: commandline_parser_get_integer
      TYPE (commandline_parser_class), INTENT(in) :: this
      CHARACTER (len=*), INTENT(in)               :: arg
      INTEGER, INTENT(in)                         :: default_value
 
!  Local arguments
      CHARACTER (len=path_length)                 :: value
      INTEGER                                     :: status
      REAL (rprec)                                :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      value = commandline_parser_get_string(this, arg)
 
      IF (trim(value) .eq. '') THEN
         commandline_parser_get_integer = default_value
 
         CALL profiler_set_stop_time('commandline_parser_get_integer',         &
     &                               start_time)
 
         RETURN
      END IF
 
      READ (value,1000,iostat=status) commandline_parser_get_integer
 
      IF (status .ne. 0) THEN
         commandline_parser_get_integer = default_value
      END IF
 
      CALL profiler_set_stop_time('commandline_parser_get_integer',            &
     &                            start_time)
 
1000  FORMAT(i20)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION commandline_parser_get_real(this, arg, default_value)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: commandline_parser_get_real
      TYPE (commandline_parser_class), INTENT(in) :: this
      CHARACTER (len=*), INTENT(in)               :: arg
      REAL (rprec), INTENT(in)                    :: default_value
 
!  Local arguments
      CHARACTER (len=path_length)                 :: value
      INTEGER                                     :: status
      REAL (rprec)                                :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      value = commandline_parser_get_string(this, arg)
 
      IF (trim(value) .eq. '') THEN
         commandline_parser_get_real = default_value
 
         CALL profiler_set_stop_time('commandline_parser_get_real',            &
     &                               start_time)
 
         RETURN
      END IF
 
      READ (value,*,iostat=status) commandline_parser_get_real
 
      IF (status .ne. 0) THEN
         commandline_parser_get_real = default_value
      END IF
 
      CALL profiler_set_stop_time('commandline_parser_get_real',               &
     &                            start_time)
 
      END FUNCTION
 
!*******************************************************************************
!  QUERY SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION commandline_parser_is_flag_set(this, arg)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL :: commandline_parser_is_flag_set
      TYPE (commandline_parser_class), INTENT(in) :: this
      CHARACTER (len=*), INTENT(in)               :: arg
 
!  Local arguments
      INTEGER                                     :: i
      REAL (rprec)                                :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
!  Loop through the arguments until the correct arg is found.
      commandline_parser_is_flag_set = .false.
 
      IF (ASSOCIATED(this%arg)) THEN
         DO i = 1, SIZE(this%arg)
            IF (trim(this%arg(i)) .eq. trim(arg)) THEN
               commandline_parser_is_flag_set = .true.
 
               CALL profiler_set_stop_time(                                    &
     &                 'commandline_parser_is_flag_set', start_time)
 
               RETURN
            END IF
         END DO
      END IF
 
      CALL profiler_set_stop_time('commandline_parser_is_flag_set',            &
     &                            start_time)
 
      END FUNCTION
 
!*******************************************************************************
!  UTILITY SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE commandline_parser_print_help
 
      IMPLICIT NONE
 
!  Start of executable code
!  All command line messages need to fit within this width.
!                '           s              c                          '
      WRITE(*,*) '                                                     '
      WRITE(*,*) '                        V3FIT                        '
      WRITE(*,*) '                                                     '
      WRITE(*,*) 'Configured with:                                     '
!$    WRITE(*,*) '  OpenMP support                                     '
#if defined(MPI_OPT)
      WRITE(*,*) '  MPI support                                        '
#endif
      WRITE(*,*) '                                                     '
      WRITE(*,*) 'Usage: xv3fit [-arg][=option] ...                    '
      WRITE(*,*) '                                                     '
      WRITE(*,*) 'Options:                                             '
      WRITE(*,*) 'All options are displayed as [arg][takesoption][text]'
      WRITE(*,*) '  -h       N Display this information                '
      WRITE(*,*) '                                                     '
      WRITE(*,*) '  -d       N Use default namelist input file         '
      WRITE(*,*) '                                                     '
      WRITE(*,*) '  -file    Y Specify the v3fit namelist input file   '
      WRITE(*,*) '                                                     '
      WRITE(*,*) '  -test    N Run unit tests                          '
      WRITE(*,*) '                                                     '
      WRITE(*,*) '  -force   N Forces the equilibrium to resolve on    '
      WRITE(*,*) '             every reconstruction parameter.         '
      WRITE(*,*) '                                                     '
!$    WRITE(*,*) '  -para    Y Determines number of parallel insatnces '
!$    WRITE(*,*) '             to run with. A value of -1 means use the'
!$    WRITE(*,*) '             default number of threads.              '
!$    WRITE(*,*) '                                                     '
      WRITE(*,*) '  -out     N Write out the input file and at each    '
      WRITE(*,*) '             step.                                   '
      WRITE(*,*) '                                                     '
      WRITE(*,*) '  -c       Y Compress magnetic response functions    '
      WRITE(*,*) '             using the cutoff. Overwrites the value  '
      WRITE(*,*) '             in the namelist input.                  '
      WRITE(*,*) '                                                     '
      WRITE(*,*) '  -c_diff  N Use central differencing to compute the '
      WRITE(*,*) '             Jacobian.                               '
      WRITE(*,*) '                                                     '
      WRITE(*,*) '  -serial  N Run the reconstruction serially and with'
      WRITE(*,*) '             parallel equilibria.                    '
      WRITE(*,*) '                                                     '
      WRITE(*,*) '  -restart Y Specify v3fit to restart from the       '
      WRITE(*,*) '             provided result file. Must have the last'
      WRITE(*,*) '             valid wout and/or siesta restart file.  '
      WRITE(*,*) '                                                     '
      WRITE(*,*) 'Notes:                                               '
      WRITE(*,*) '  If no -arg is found -file is implicitly implied.   '
      WRITE(*,*) 'The default input filename is v3fit.in.              '
      WRITE(*,*) '                                                     '
 
      stop
 
      END SUBROUTINE
 
      END MODULE