New URL for NEMO forge!   http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.
Changeset 6225 for branches/2014/dev_r4704_NOC5_MPP_BDY_UPDATE/NEMOGCM/TOOLS/SIREN/src/logger.f90 – NEMO

Ignore:
Timestamp:
2016-01-08T10:35:19+01:00 (8 years ago)
Author:
jamesharle
Message:

Update MPP_BDY_UPDATE branch to be consistent with head of trunk

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/2014/dev_r4704_NOC5_MPP_BDY_UPDATE/NEMOGCM/TOOLS/SIREN/src/logger.f90

    r4213 r6225  
    66! 
    77! DESCRIPTION: 
    8 !> @brief This module create logger file and inform it depending  
    9 !>  of verbosity choose between : 
     8!> @brief This module create logger file and allow to fill it depending of verbosity. 
     9!> @details 
     10!> verbosity could be choosen between : 
    1011!>    - trace : Most detailed information. 
    1112!>    - debug : Detailed information on the flow through the system. 
    … …  
    1516!> but not necessarily "wrong".  
    1617!>    - error : Other runtime errors or unexpected conditions. 
    17 !>    - fatal : Severe errors that cause premature termination.<br /> 
     18!>    - fatal : Severe errors that cause premature termination. 
    1819!>  default verbosity is warning 
     20!>    - none  : to not create and write any information in logger file.<br /> 
    1921! 
    20 !> @details 
    21 !>    If total number of error exceeded maximum number  
    22 !>    authorized, program stop. 
    23 !> 
    24 !>    to open/create logger file:<br/> 
    25 !>    CALL logger_open(cd_file, [cd_verbosity,] [id_loggerid,] [id_maxerror]) 
    26 !>       - cd_file is logger file name 
    27 !>       - cd_verbosity is verbosity to be used (optional, default 'warning') 
    28 !>       - id_loggerid is file id (optional, use only to flush) 
    29 !>       - id_maxerror is the mximum number of error authorized before stop program (optional, default 5) 
    30 !> 
    31 !>    to close logger file:<br/> 
    32 !>    CALL logger_close() 
    33 !> 
    34 !>    to write header in logger file:<br/> 
    35 !>    CALL logger_header() 
    36 !> 
    37 !>    to write footer in logger file:<br/> 
    38 !>    CALL logger_footer() 
    39 !> 
    40 !>    to flushing output:<br/> 
    41 !>    CALL logger_flush() 
    42 !> 
    43 !>    to write TRACE message in logger file:<br/> 
    44 !>    CALL logger_trace(cd_msg) 
    45 !>       - cd_msg is TRACE message 
    46 !> 
    47 !>    to write DEBUG message in logger file:<br/> 
    48 !>    CALL logger_debug(cd_msg) 
    49 !>       - cd_msg is DEBUG message 
    50 !> 
    51 !>    to write INFO message in logger file:<br/> 
    52 !>    CALL logger_info(cd_msg) 
    53 !>       - cd_msg is INFO message 
    54 !> 
    55 !>    to write WARNING message in logger file:<br/> 
    56 !>    CALL logger_warn(cd_msg) 
    57 !>       - cd_msg is WARNING message 
    58 !> 
    59 !>    to write ERROR message in logger file:<br/> 
    60 !>    CALL logger_error(cd_msg) 
    61 !>       - cd_msg is ERROR message 
    62 !> 
    63 !>    to write FATAL message in logger file:<br/> 
    64 !>    CALL logger_fatal(cd_msg) 
    65 !>       - cd_msg is FATAL message 
    66 !> 
    67 !>  Examples :<br /> 
     22!> If total number of error exceeded maximum number  
     23!> authorized, program stop. 
     24!> 
     25!> to open/create logger file:<br/> 
     26!> @code 
     27!>    CALL logger_open(cd_file, [cd_verbosity,] [id_maxerror,] [id_loggerid]) 
     28!> @endcode 
     29!> - cd_file is logger file name 
     30!> - cd_verbosity is verbosity to be used [optional, default 'warning'] 
     31!> - id_loggerid is file id [optional, use only to flush] 
     32!> - id_maxerror is the maximum number of error authorized before program stop [optional, default 5] 
     33!> 
     34!> to close logger file:<br/> 
     35!> @code 
     36!> CALL logger_close() 
     37!> @endcode 
     38!> 
     39!> to write header in logger file:<br/> 
     40!> @code 
     41!> CALL logger_header() 
     42!> @endcode 
     43!> 
     44!> to write footer in logger file:<br/> 
     45!> @code 
     46!> CALL logger_footer() 
     47!> @endcode 
     48!> 
     49!> to flushing output:<br/> 
     50!> @code 
     51!> CALL logger_flush() 
     52!> @endcode 
     53!> 
     54!> to write TRACE message in logger file:<br/> 
     55!> @code 
     56!> CALL logger_trace(cd_msg [,ld_flush]) 
     57!> @endcode 
     58!>    - cd_msg is TRACE message 
     59!>    - ld_flush to flush output [optional] 
     60!> 
     61!> to write DEBUG message in logger file:<br/> 
     62!> @code 
     63!> CALL logger_debug(cd_msg [,ld_flush]) 
     64!> @endcode 
     65!>    - cd_msg is DEBUG message 
     66!>    - ld_flush to flush output [optional] 
     67!> 
     68!> to write INFO message in logger file:<br/> 
     69!> @code 
     70!> CALL logger_info(cd_msg [,ld_flush]) 
     71!> @endcode 
     72!>    - cd_msg is INFO message 
     73!>    - ld_flush to flush output [optional] 
     74!> 
     75!> to write WARNING message in logger file:<br/> 
     76!> @code 
     77!> CALL logger_warn(cd_msg [,ld_flush]) 
     78!> @endcode 
     79!>    - cd_msg is WARNING message 
     80!>    - ld_flush to flush output [optional] 
     81!> 
     82!> to write ERROR message in logger file:<br/> 
     83!> @code 
     84!> CALL logger_error(cd_msg [,ld_flush]) 
     85!> @endcode 
     86!>    - cd_msg is ERROR message 
     87!>    - ld_flush to flush output [optional] 
     88!> 
     89!> to write FATAL message in logger file:<br/> 
     90!> @code 
     91!> CALL logger_fatal(cd_msg) 
     92!> @endcode 
     93!>    - cd_msg is FATAL message 
     94!> 
     95!> Examples :<br /> 
     96!> @code 
    6897!>   CALL logger_open('loggerfile.txt','info') 
    6998!> 
    70 !>   CALL logger_header()<br /> 
    71 !>   CALL logger_info('une petite info')<br /> 
    72 !>   CALL logger_debug('une info de debug')<br /> 
    73 !>   CALL logger_warn('une info de warning')<br /> 
    74 !>   CALL logger_error('une info d erreur')<br /> 
    75 !>   CALL logger_footer()<br /> 
    76 !>   CALL logger_close()<br /> 
    77 !> 
    78 !> !--------------------------------------------------------------------<br /> 
     99!>   CALL logger_header() 
     100!>   CALL logger_debug('une info de debug') 
     101!>   CALL logger_info('une info') 
     102!>   CALL logger_warn('un warning') 
     103!>   CALL logger_error('une erreur') 
     104!>   CALL logger_footer() 
     105!>   CALL logger_close() 
     106!> @endcode 
     107!> 
     108!> @code 
    79109!>   CALL logger_open('loggerfile.txt') 
    80110!> 
    81 !>   CALL logger_header()<br /> 
    82 !>   CALL logger_info('une petite info')<br /> 
    83 !>   CALL logger_debug('une info de debug')<br /> 
    84 !>   CALL logger_warn('une info de warning')<br /> 
    85 !>   CALL logger_error('une info d erreur')<br /> 
    86 !>   CALL logger_footer()<br /> 
    87 !>   CALL logger_close()<br /> 
     111!>   CALL logger_header() 
     112!>   CALL logger_debug('une info de debug') 
     113!>   CALL logger_info('une info') 
     114!>   CALL logger_warn('un warning') 
     115!>   CALL logger_error('une erreur') 
     116!>   CALL logger_footer() 
     117!>   CALL logger_close() 
     118!> @endcode 
    88119! 
    89120!> @author 
    90121!> J.Paul 
    91122! REVISION HISTORY: 
    92 !> @date Nov, 2013- Initial Version 
     123!> @date November, 2013 - Initial Version 
     124!> @date February, 2015 
     125!> - check verbosity validity 
     126!> - add 'none' verbosity level to not used logger file 
    93127!> 
    94128!> @note Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt) 
    95 !> 
    96 !> @todo 
    97 !> - verifier flush remet pas compteur error à zero 
    98129!---------------------------------------------------------------------- 
    99130MODULE logger 
    … …  
    101132   USE fct                             ! basic useful function 
    102133   IMPLICIT NONE 
    103    PRIVATE 
    104134   ! NOTE_avoid_public_variables_if_possible 
    105135 
    106136   ! type and variable 
    107    !PUBLIC :: TLOGGER            ! logger structure 
     137   PRIVATE :: TLOGGER            !< logger structure 
     138 
     139   PRIVATE :: tm_logger          !< logger structure 
     140   PRIVATE :: im_nverbosity      !< number of log level 
     141   PRIVATE :: cm_verbosity       !< verbosity array 
    108142 
    109143   ! function and subroutine 
    110    PUBLIC :: logger_open        ! create a log file with given verbosity 
    111    PUBLIC :: logger_close       ! close log file 
    112    PUBLIC :: logger_flush       ! flushing output 
    113    PUBLIC :: logger_header      ! write header on log file 
    114    PUBLIC :: logger_footer      ! write footer on log file 
    115    PUBLIC :: logger_trace       ! write trace    message in log file 
    116    PUBLIC :: logger_debug       ! write debug    message in log file  
    117    PUBLIC :: logger_info        ! write info     message in log file 
    118    PUBLIC :: logger_warn        ! write warning  message in log file 
    119    PUBLIC :: logger_error       ! write error    message in log file 
    120    PUBLIC :: logger_fatal       ! write fatal    message in log file, and stop 
     144   PUBLIC :: logger_open        !< create a log file with given verbosity 
     145   PUBLIC :: logger_close       !< close log file 
     146   PUBLIC :: logger_header      !< write header on log file 
     147   PUBLIC :: logger_footer      !< write footer on log file 
     148   PUBLIC :: logger_flush       !< flushing output 
     149   PUBLIC :: logger_trace       !< write trace    message in log file 
     150   PUBLIC :: logger_debug       !< write debug    message in log file  
     151   PUBLIC :: logger_info        !< write info     message in log file 
     152   PUBLIC :: logger_warn        !< write warning  message in log file 
     153   PUBLIC :: logger_error       !< write error    message in log file 
     154   PUBLIC :: logger_fatal       !< write fatal    message in log file, and stop 
    121155 
    122156   PRIVATE :: logger__write     ! cut message to get maximum of 80 character by line in log file 
    123  
    124    !> @struct TLOG 
    125    TYPE TLOGGER 
     157   PRIVATE :: logger__check_verb! check verbosity validity 
     158 
     159   TYPE TLOGGER   !< logger structure 
    126160      INTEGER(i4)       :: i_id = 0                 !< log file id 
     161      LOGICAL           :: l_use=.TRUE.             !< use logger or not 
    127162      CHARACTER(LEN=lc) :: c_name                   !< log file name 
    128163      CHARACTER(LEN=lc) :: c_verbosity = "warning"  !< verbosity choose 
    129       CHARACTER(LEN=lc) :: c_verb = ""              !< table of "verbosities" to used  
     164      CHARACTER(LEN=lc) :: c_verb = ""              !< array of "verbosities" to used  
    130165      INTEGER(i4)       :: i_nerror   = 0           !< number of error 
    131166      INTEGER(i4)       :: i_nfatal   = 0           !< number of fatal error 
    … …  
    134169 
    135170   !  module variable 
    136    INTEGER(i4), PARAMETER :: im_nverbosity=6     !< number of log level 
    137    CHARACTER(len=*), DIMENSION(im_nverbosity), PARAMETER :: cm_verbosity= & !< verbosity table  
     171   INTEGER(i4), PARAMETER :: im_nverbosity=7     !< number of log level 
     172   CHARACTER(len=*), DIMENSION(im_nverbosity), PARAMETER :: cm_verbosity= & !< verbosity array  
    138173   &               (/ 'trace   ',& 
    139174   &                  'debug   ',& 
    … …  
    141176   &                  'warning ',& 
    142177   &                  'error   ',& 
    143    &                  'fatal   '/) 
     178   &                  'fatal   ',& 
     179   &                  'none    '/) 
    144180 
    145181   TYPE(TLOGGER), SAVE :: tm_logger      !< logger structure 
    … …  
    147183CONTAINS 
    148184   !------------------------------------------------------------------- 
    149    !> @brief This subroutine create a log file with given verbosity. 
    150    !> 
    151    !> @author J.Paul 
    152    !> - Nov, 2013- Initial Version 
    153    ! 
    154    !> @param[in] cd_file : log file name 
    155    !> @param[in] cd_verbosity : log file verbosity 
    156    !> @param[in] id_logid : log file id (use to flush) 
    157    !> @param[in] id_maxerror : maximum number of error 
    158    !------------------------------------------------------------------- 
    159    ! @code 
    160    SUBROUTINE logger_open(cd_file, cd_verbosity, id_logid, id_maxerror) 
     185   !> @brief This subroutine create a log file with default verbosity 
     186   !> ('warning'). 
     187   !> @details 
     188   !> Optionally verbosity could be change to  
     189   !> ('trace','debug','info',warning','error','fatal').<br/> 
     190   !> Optionally maximum number of error allowed could be change. 
     191   !> 
     192   !> @author J.Paul 
     193   !> @date November, 2013 - Initial Version 
     194   ! 
     195   !> @param[in] cd_file      log file name 
     196   !> @param[in] cd_verbosity log file verbosity 
     197   !> @param[in] id_maxerror  maximum number of error 
     198   !> @param[in] id_logid     log file id (use to flush) 
     199   !------------------------------------------------------------------- 
     200   SUBROUTINE logger_open(cd_file, cd_verbosity, id_maxerror, id_logid) 
    161201      IMPLICIT NONE 
    162202      ! Argument 
    163203      CHARACTER(len=*), INTENT(IN) :: cd_file                ! log file name 
    164204      CHARACTER(len=*), INTENT(IN), OPTIONAL :: cd_verbosity ! log file verbosity 
     205      INTEGER(i4),      INTENT(IN), OPTIONAL :: id_maxerror  ! log max error 
    165206      INTEGER(i4),      INTENT(IN), OPTIONAL :: id_logid     ! log file id 
    166       INTEGER(i4),      INTENT(IN), OPTIONAL :: id_maxerror  ! log max error 
    167207 
    168208      ! local variable 
    169209      INTEGER(i4) :: il_status 
    170210 
     211      LOGICAL     :: ll_valid 
     212 
    171213      ! loop 
    172214      INTEGER(i4) :: ji 
    173215      !---------------------------------------------------------------- 
    174       ! get id if not already define 
    175       IF( PRESENT(id_logid) )THEN 
    176          tm_logger%i_id=id_logid 
    177       ELSE 
    178          tm_logger%i_id=fct_getunit() 
    179       ENDIF 
    180  
    181       ! open log file 
    182       OPEN( tm_logger%i_id, & 
    183       &     STATUS="unknown",    & 
    184       &     FILE=TRIM(ADJUSTL(cd_file)),  & 
    185       &     ACTION="write",      & 
    186       &     POSITION="append",   & 
    187       &     IOSTAT=il_status) 
    188       CALL fct_err(il_status) 
    189  
    190       ! keep filename 
    191       tm_logger%c_name=TRIM(ADJUSTL(cd_file)) 
    192216 
    193217      ! if present, change verbosity value 
    194218      IF( PRESENT(cd_verbosity) )THEN 
    195          tm_logger%c_verbosity=TRIM(ADJUSTL(cd_verbosity)) 
    196       ENDIF 
    197  
    198       ! compute "tab" of verbosity to be used 
    199       IF( TRIM(ADJUSTL(tm_logger%c_verb)) == "" )THEN 
    200          DO ji=im_nverbosity,1,-1 
    201             tm_logger%c_verb = & 
    202             &  TRIM(tm_logger%c_verb)//" "//TRIM(ADJUSTL(cm_verbosity(ji))) 
    203             IF( TRIM(tm_logger%c_verbosity) == TRIM(cm_verbosity(ji)) )THEN 
    204                EXIT 
    205             ENDIF 
    206          ENDDO 
    207       ENDIF 
    208  
    209       IF( PRESENT(id_maxerror) )THEN 
    210          tm_logger%i_maxerror=id_maxerror 
     219         ll_valid=logger__check_verb(TRIM(ADJUSTL(cd_verbosity))) 
     220         IF( ll_valid )THEN 
     221            tm_logger%c_verbosity=TRIM(ADJUSTL(cd_verbosity)) 
     222         ENDIF 
     223      ENDIF 
     224 
     225      IF( TRIM(tm_logger%c_verbosity) == 'none' ) tm_logger%l_use=.FALSE. 
     226       
     227      IF( tm_logger%l_use )THEN 
     228 
     229         ! get id if not already define 
     230         IF( PRESENT(id_logid) )THEN 
     231            tm_logger%i_id=id_logid 
     232         ELSE 
     233            tm_logger%i_id=fct_getunit() 
     234         ENDIF 
     235 
     236         ! open log file 
     237         OPEN( tm_logger%i_id, & 
     238         &     STATUS="unknown",    & 
     239         &     FILE=TRIM(ADJUSTL(cd_file)),  & 
     240         &     ACTION="write",      & 
     241         &     POSITION="append",   & 
     242         &     IOSTAT=il_status) 
     243         CALL fct_err(il_status) 
     244 
     245         ! keep filename 
     246         tm_logger%c_name=TRIM(ADJUSTL(cd_file)) 
     247 
     248         ! compute "tab" of verbosity to be used 
     249         IF( TRIM(ADJUSTL(tm_logger%c_verb)) == "" )THEN 
     250            DO ji=im_nverbosity,1,-1 
     251               tm_logger%c_verb = & 
     252               &  TRIM(tm_logger%c_verb)//" "//TRIM(ADJUSTL(cm_verbosity(ji))) 
     253               IF( TRIM(tm_logger%c_verbosity) == TRIM(cm_verbosity(ji)) )THEN 
     254                  EXIT 
     255               ENDIF 
     256            ENDDO 
     257         ENDIF 
     258 
     259         IF( PRESENT(id_maxerror) )THEN 
     260            tm_logger%i_maxerror=id_maxerror 
     261         ENDIF 
     262 
    211263      ENDIF 
    212264 
    213265   END SUBROUTINE logger_open 
    214    ! @endcode 
    215266   !------------------------------------------------------------------- 
    216267   !> @brief This subroutine close a log file. 
    217268   !> 
    218269   !> @author J.Paul 
    219    !> - Nov, 2013- Initial Version 
    220    ! 
    221    !------------------------------------------------------------------- 
    222    ! @code 
     270   !> @date November, 2013 - Initial Version 
     271   !------------------------------------------------------------------- 
    223272   SUBROUTINE logger_close() 
    224273      IMPLICIT NONE 
    … …  
    226275      INTEGER(i4) :: il_status 
    227276      !---------------------------------------------------------------- 
    228       IF( tm_logger%i_id /= 0 )THEN 
    229          CLOSE( tm_logger%i_id, & 
    230          &      IOSTAT=il_status)       
    231          CALL fct_err(il_status) 
    232       ELSE 
    233           CALL logger_open('logger.log') 
    234           CALL logger_header() 
    235           CALL logger_fatal('you must have create logger to use logger_close') 
     277      IF( tm_logger%l_use )THEN 
     278         IF( tm_logger%i_id /= 0 )THEN 
     279            tm_logger%i_id = 0 
     280            CLOSE( tm_logger%i_id, & 
     281            &      IOSTAT=il_status)       
     282            CALL fct_err(il_status) 
     283         ELSE 
     284             CALL logger_open('logger.log') 
     285             CALL logger_header() 
     286             CALL logger_fatal('you must have create logger to use logger_close') 
     287         ENDIF 
    236288      ENDIF 
    237289 
    238290   END SUBROUTINE logger_close 
    239    ! @endcode 
    240291   !------------------------------------------------------------------- 
    241292   !> @brief This subroutine flushing output into log file. 
    242293   !> 
    243294   !> @author J.Paul 
    244    !> - Nov, 2013- Initial Version 
    245    ! 
    246    !------------------------------------------------------------------- 
    247    ! @code 
     295   !> @date November, 2013 - Initial Version 
     296   !------------------------------------------------------------------- 
    248297   SUBROUTINE logger_flush() 
    249298      IMPLICIT NONE 
    250299      !---------------------------------------------------------------- 
    251       IF( tm_logger%i_id /= 0 )THEN 
    252          CALL logger_close() 
    253          CALL logger_open( tm_logger%c_name, tm_logger%c_verbosity, tm_logger%i_id, & 
    254          &              tm_logger%i_maxerror )      
    255       ELSE 
    256           CALL logger_open('logger.log') 
    257           CALL logger_header() 
    258           CALL logger_fatal('you must have create logger to use logger_flush') 
     300      IF( tm_logger%l_use )THEN 
     301         IF( tm_logger%i_id /= 0 )THEN 
     302            CALL logger_close() 
     303            CALL logger_open( tm_logger%c_name, tm_logger%c_verbosity, & 
     304            &                 tm_logger%i_maxerror, tm_logger%i_id )      
     305         ELSE 
     306             CALL logger_open('logger.log') 
     307             CALL logger_header() 
     308             CALL logger_fatal('you must have create logger to use logger_flush') 
     309         ENDIF 
    259310      ENDIF 
    260311 
    261312   END SUBROUTINE logger_flush 
    262    ! @endcode    
    263313   !------------------------------------------------------------------- 
    264314   !> @brief This subroutine write header on log file. 
    265315   !> 
    266316   !> @author J.Paul 
    267    !> - Nov, 2013- Initial Version 
    268    ! 
    269    !------------------------------------------------------------------- 
    270    ! @code 
     317   !> @date November, 2013 - Initial Version 
     318   !------------------------------------------------------------------- 
    271319   RECURSIVE SUBROUTINE logger_header() 
    272320      IMPLICIT NONE 
    273321      ! local variable 
    274       INTEGER(i4) :: il_status 
    275       !---------------------------------------------------------------- 
    276       IF( tm_logger%i_id /= 0 )THEN 
    277          WRITE( tm_logger%i_id,    & 
    278             &   FMT='(a/a/a)',     & 
    279             &   IOSTAT=il_status ) & 
    280             &   "--------------------------------------------------", & 
    281             &   "INIT     : log start with verbosity "//& 
    282             &   TRIM(tm_logger%c_verbosity), & 
    283             &   "--------------------------------------------------" 
    284          CALL fct_err(il_status) 
    285       ELSE 
    286           CALL logger_open('logger.log') 
    287           CALL logger_header() 
    288           CALL logger_fatal('you must have create logger to use logger_header') 
     322      INTEGER(i4)       :: il_status 
     323      !---------------------------------------------------------------- 
     324      IF( tm_logger%l_use )THEN 
     325         IF( tm_logger%i_id /= 0 )THEN 
     326            WRITE( tm_logger%i_id,    & 
     327               &   FMT='(4(a/))',     & 
     328               &   IOSTAT=il_status ) & 
     329               &   "--------------------------------------------------",& 
     330               &   "INIT     : verbosity "//TRIM(tm_logger%c_verbosity),& 
     331               &   "INIT     : max error "//TRIM(fct_str(tm_logger%i_maxerror)), & 
     332               &   "--------------------------------------------------" 
     333            CALL fct_err(il_status) 
     334         ELSE 
     335             CALL logger_open('logger.log') 
     336             CALL logger_header() 
     337             CALL logger_fatal('you must have create logger to use logger_header') 
     338         ENDIF 
    289339      ENDIF 
    290340 
    291341   END SUBROUTINE logger_header 
    292    ! @endcode    
    293342   !------------------------------------------------------------------- 
    294343   !> @brief This subroutine write footer on log file. 
    295344   !> 
    296345   !> @author J.Paul 
    297    !> - Nov, 2013- Initial Version 
    298    ! 
    299    !------------------------------------------------------------------- 
    300    ! @code 
     346   !> @date November, 2013 - Initial Version 
     347   !------------------------------------------------------------------- 
    301348   SUBROUTINE logger_footer() 
    302349      IMPLICIT NONE 
    303350      ! local variable 
    304       INTEGER(i4) :: il_status 
    305       !---------------------------------------------------------------- 
    306       IF( tm_logger%i_id /= 0 )THEN 
    307          WRITE( tm_logger%i_id,    & 
    308             &   FMT='(a/a/a/a/a)',     & 
    309             &   IOSTAT=il_status ) & 
    310             &   "--------------------------------------------------",& 
    311             &   "END      : log ended ",                             & 
    312             &   "END      : "//TRIM(fct_str(tm_logger%i_nerror))//   & 
    313             &   " ERROR detected ",                                  & 
    314             &   "END      : "//TRIM(fct_str(tm_logger%i_nfatal))//   & 
    315             &   " FATAL detected ",                                  & 
    316             &   "--------------------------------------------------" 
    317          CALL fct_err(il_status) 
    318       ELSE 
    319           CALL logger_open('logger.log') 
    320           CALL logger_header() 
    321           CALL logger_fatal('you must have create logger to use logger_footer') 
     351      INTEGER(i4)       :: il_status 
     352      !---------------------------------------------------------------- 
     353      IF( tm_logger%l_use )THEN 
     354         IF( tm_logger%i_id /= 0 )THEN 
     355            WRITE( tm_logger%i_id,    & 
     356               &   FMT='(4(/a))',     & 
     357               &   IOSTAT=il_status ) & 
     358               &   "--------------------------------------------------",& 
     359               &   "END      : log ended ",              & 
     360               &   "END      : "//TRIM(fct_str(tm_logger%i_nerror))//   & 
     361               &   " ERROR detected ",                                  & 
     362               &   "END      : "//TRIM(fct_str(tm_logger%i_nfatal))//   & 
     363               &   " FATAL detected ",                                  & 
     364               &   "--------------------------------------------------" 
     365            CALL fct_err(il_status) 
     366         ELSE 
     367             CALL logger_open('logger.log') 
     368             CALL logger_header() 
     369             CALL logger_fatal('you must have create logger to use logger_footer') 
     370         ENDIF 
    322371      ENDIF 
    323372   END SUBROUTINE logger_footer 
    324    ! @endcode    
    325373   !------------------------------------------------------------------- 
    326374   !> @brief This subroutine write trace message on log file. 
    327    !> 
    328    !> @author J.Paul 
    329    !> - Nov, 2013- Initial Version 
    330    ! 
    331    !> @param[in] cd_msg : message to write 
    332    !> @param[in] ld_flush : flushing ouput 
    333    ! 
    334    !------------------------------------------------------------------- 
    335    ! @code 
     375   !> @details 
     376   !> Optionally you could flush output. 
     377   !> 
     378   !> @author J.Paul 
     379   !> @date November, 2013 - Initial Version 
     380   ! 
     381   !> @param[in] cd_msg    message to write 
     382   !> @param[in] ld_flush  flushing ouput 
     383   !------------------------------------------------------------------- 
    336384   SUBROUTINE logger_trace(cd_msg, ld_flush) 
    337385      IMPLICIT NONE 
    … …  
    340388      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush 
    341389      !---------------------------------------------------------------- 
    342       IF( tm_logger%i_id /= 0 )THEN 
    343          IF( INDEX(TRIM(tm_logger%c_verb),'trace')/=0 )THEN 
    344  
    345             CALL logger__write("TRACE   :",cd_msg) 
    346  
    347             IF( PRESENT(ld_flush) )THEN 
    348                IF( ld_flush )THEN 
    349                   CALL logger_flush() 
    350                ENDIF 
    351             ENDIF       
    352          ENDIF 
    353       ELSE 
    354           CALL logger_open('logger.log') 
    355           CALL logger_header() 
    356           CALL logger_fatal('you must have create logger to use logger_trace') 
     390      IF( tm_logger%l_use )THEN 
     391         IF( tm_logger%i_id /= 0 )THEN 
     392            IF( INDEX(TRIM(tm_logger%c_verb),'trace')/=0 )THEN 
     393 
     394               CALL logger__write("TRACE   :",cd_msg) 
     395 
     396               IF( PRESENT(ld_flush) )THEN 
     397                  IF( ld_flush )THEN 
     398                     CALL logger_flush() 
     399                  ENDIF 
     400               ENDIF       
     401            ENDIF 
     402         ELSE 
     403             CALL logger_open('logger.log') 
     404             CALL logger_header() 
     405             CALL logger_fatal('you must have create logger to use logger_trace') 
     406         ENDIF 
    357407      ENDIF 
    358408   END SUBROUTINE logger_trace 
    359    ! @endcode    
    360409   !------------------------------------------------------------------- 
    361410   !> @brief This subroutine write debug message on log file. 
    362    !> 
    363    !> @author J.Paul 
    364    !> - Nov, 2013- Initial Version 
    365    ! 
    366    !> @param[in] cd_msg : message to write 
    367    !> @param[in] ld_flush : flushing ouput 
    368    ! 
    369    !------------------------------------------------------------------- 
    370    ! @code 
     411   !> @details 
     412   !> Optionally you could flush output. 
     413   !> 
     414   !> @author J.Paul 
     415   !> @date November, 2013 - Initial Version 
     416   ! 
     417   !> @param[in] cd_msg    message to write 
     418   !> @param[in] ld_flush  flushing ouput 
     419   !------------------------------------------------------------------- 
    371420   SUBROUTINE logger_debug(cd_msg, ld_flush) 
    372421      IMPLICIT NONE 
    … …  
    375424      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush 
    376425      !---------------------------------------------------------------- 
    377       IF( tm_logger%i_id /= 0 )THEN 
    378          IF( INDEX(TRIM(tm_logger%c_verb),'debug')/=0 )THEN 
    379  
    380             CALL logger__write("DEBUG   :",cd_msg) 
    381  
    382             IF( PRESENT(ld_flush) )THEN 
    383                IF( ld_flush )THEN 
    384                   CALL logger_flush() 
    385                ENDIF 
    386             ENDIF       
    387          ENDIF 
    388       ELSE 
    389           CALL logger_open('logger.log') 
    390           CALL logger_header() 
    391           CALL logger_fatal('you must have create logger to use logger_debug') 
     426      IF( tm_logger%l_use )THEN 
     427         IF( tm_logger%i_id /= 0 )THEN 
     428            IF( INDEX(TRIM(tm_logger%c_verb),'debug')/=0 )THEN 
     429 
     430               CALL logger__write("DEBUG   :",cd_msg) 
     431 
     432               IF( PRESENT(ld_flush) )THEN 
     433                  IF( ld_flush )THEN 
     434                     CALL logger_flush() 
     435                  ENDIF 
     436               ENDIF       
     437            ENDIF 
     438         ELSE 
     439             CALL logger_open('logger.log') 
     440             CALL logger_header() 
     441             CALL logger_fatal('you must have create logger to use logger_debug') 
     442         ENDIF 
    392443      ENDIF 
    393444   END SUBROUTINE logger_debug 
    394    ! @endcode    
    395445   !------------------------------------------------------------------- 
    396446   !> @brief This subroutine write info message on log file. 
    397    !> 
    398    !> @author J.Paul 
    399    !> - Nov, 2013- Initial Version 
    400    ! 
    401    !> @param[in] cd_msg : message to write 
    402    !> @param[in] ld_flush : flushing ouput 
    403    ! 
    404    !------------------------------------------------------------------- 
    405    ! @code 
     447   !> @details 
     448   !> Optionally you could flush output. 
     449   !> 
     450   !> @author J.Paul 
     451   !> @date November, 2013 - Initial Version 
     452   ! 
     453   !> @param[in] cd_msg    message to write 
     454   !> @param[in] ld_flush  flushing ouput 
     455   !------------------------------------------------------------------- 
    406456   SUBROUTINE logger_info(cd_msg, ld_flush) 
    407457      IMPLICIT NONE 
    … …  
    410460      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush 
    411461      !---------------------------------------------------------------- 
    412       IF( tm_logger%i_id /= 0 )THEN 
    413          IF( INDEX(TRIM(tm_logger%c_verb),'info')/=0 )THEN 
    414  
    415             CALL logger__write("INFO    :",cd_msg) 
    416  
    417             IF( PRESENT(ld_flush) )THEN 
    418                IF( ld_flush )THEN 
    419                   CALL logger_flush() 
    420                ENDIF 
    421             ENDIF       
    422          ENDIF 
    423       ELSE 
    424           CALL logger_open('logger.log') 
    425           CALL logger_header() 
    426           CALL logger_fatal('you must have create logger to use logger_info') 
     462      IF( tm_logger%l_use )THEN 
     463         IF( tm_logger%i_id /= 0 )THEN 
     464            IF( INDEX(TRIM(tm_logger%c_verb),'info')/=0 )THEN 
     465 
     466               CALL logger__write("INFO    :",cd_msg) 
     467 
     468               IF( PRESENT(ld_flush) )THEN 
     469                  IF( ld_flush )THEN 
     470                     CALL logger_flush() 
     471                  ENDIF 
     472               ENDIF       
     473            ENDIF 
     474         ELSE 
     475             CALL logger_open('logger.log') 
     476             CALL logger_header() 
     477             CALL logger_fatal('you must have create logger to use logger_info') 
     478         ENDIF 
    427479      ENDIF 
    428480   END SUBROUTINE logger_info 
    429    ! @endcode     
    430481   !------------------------------------------------------------------- 
    431482   !> @brief This subroutine write warning message on log file. 
    432    !> 
    433    !> @author J.Paul 
    434    !> - Nov, 2013- Initial Version 
    435    ! 
    436    !> @param[in] cd_msg : message to write 
    437    !> @param[in] ld_flush : flushing ouput 
    438    ! 
    439    !------------------------------------------------------------------- 
    440    ! @code 
     483   !> @details 
     484   !> Optionally you could flush output. 
     485   !> 
     486   !> @author J.Paul 
     487   !> @date November, 2013 - Initial Version 
     488   ! 
     489   !> @param[in] cd_msg    message to write 
     490   !> @param[in] ld_flush  flushing ouput 
     491   !------------------------------------------------------------------- 
    441492   SUBROUTINE logger_warn(cd_msg, ld_flush) 
    442493      IMPLICIT NONE 
    … …  
    445496      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush 
    446497      !---------------------------------------------------------------- 
    447       IF( tm_logger%i_id /= 0 )THEN 
    448          IF( INDEX(TRIM(tm_logger%c_verb),'warn')/=0 )THEN 
    449  
    450             CALL logger__write("WARNING :",cd_msg) 
    451  
    452             IF( PRESENT(ld_flush) )THEN 
    453                IF( ld_flush )THEN 
    454                   CALL logger_flush() 
    455                ENDIF 
    456             ENDIF       
    457          ENDIF 
    458       ELSE 
    459           CALL logger_open('logger.log') 
    460           CALL logger_header() 
    461           CALL logger_fatal('you must have create logger to use logger_warn') 
     498      IF( tm_logger%l_use )THEN 
     499         IF( tm_logger%i_id /= 0 )THEN 
     500            IF( INDEX(TRIM(tm_logger%c_verb),'warn')/=0 )THEN 
     501 
     502               CALL logger__write("WARNING :",cd_msg) 
     503 
     504               IF( PRESENT(ld_flush) )THEN 
     505                  IF( ld_flush )THEN 
     506                     CALL logger_flush() 
     507                  ENDIF 
     508               ENDIF       
     509            ENDIF 
     510         ELSE 
     511             CALL logger_open('logger.log') 
     512             CALL logger_header() 
     513             CALL logger_fatal('you must have create logger to use logger_warn') 
     514         ENDIF 
    462515      ENDIF 
    463516   END SUBROUTINE logger_warn 
    464    ! @endcode    
    465517   !------------------------------------------------------------------- 
    466518   !> @brief This subroutine write error message on log file. 
    467    !> 
    468    !> @author J.Paul 
    469    !> - Nov, 2013- Initial Version 
    470    ! 
    471    !> @param[in] cd_msg : message to write 
    472    !> @param[in] ld_flush : flushing ouput 
    473    ! 
    474    !------------------------------------------------------------------- 
    475    ! @code 
     519   !> @details 
     520   !> Optionally you could flush output. 
     521   !> 
     522   !> @author J.Paul 
     523   !> @date November, 2013 - Initial Version 
     524   ! 
     525   !> @param[in] cd_msg    message to write 
     526   !> @param[in] ld_flush  flushing ouput 
     527   !------------------------------------------------------------------- 
    476528   SUBROUTINE logger_error(cd_msg, ld_flush) 
    477529      IMPLICIT NONE 
    … …  
    483535      CHARACTER(LEN=lc) :: cl_nerror 
    484536      !---------------------------------------------------------------- 
    485       IF( tm_logger%i_id /= 0 )THEN 
    486          ! increment the error number 
    487          tm_logger%i_nerror=tm_logger%i_nerror+1 
    488  
    489          IF( INDEX(TRIM(tm_logger%c_verb),'error')/=0 )THEN 
    490  
    491             CALL logger__write("ERROR   :",cd_msg) 
    492  
    493             IF( PRESENT(ld_flush) )THEN 
    494                IF( ld_flush )THEN 
    495                   CALL logger_flush() 
    496                ENDIF 
    497             ENDIF       
    498          ENDIF 
    499  
    500          IF( tm_logger%i_nerror >= tm_logger%i_maxerror )THEN 
    501             WRITE(cl_nerror,*) tm_logger%i_maxerror 
    502             CALL logger_fatal(& 
    503             &  'Error count reached limit of '//TRIM(ADJUSTL(cl_nerror)) ) 
    504          ENDIF 
    505       ELSE 
    506           CALL logger_open('logger.log') 
    507           CALL logger_header() 
    508           CALL logger_fatal('you must have create logger to use logger_error') 
    509       ENDIF 
    510  
     537      IF( tm_logger%l_use )THEN 
     538         IF( tm_logger%i_id /= 0 )THEN 
     539            IF( TRIM(tm_logger%c_verb) /= 'none' )THEN 
     540               ! increment the error number 
     541               tm_logger%i_nerror=tm_logger%i_nerror+1 
     542            ENDIF 
     543 
     544            IF( INDEX(TRIM(tm_logger%c_verb),'error')/=0 )THEN 
     545 
     546               CALL logger__write("ERROR   :",cd_msg) 
     547 
     548               IF( PRESENT(ld_flush) )THEN 
     549                  IF( ld_flush )THEN 
     550                     CALL logger_flush() 
     551                  ENDIF 
     552               ENDIF       
     553            ENDIF 
     554 
     555            IF( tm_logger%i_nerror >= tm_logger%i_maxerror )THEN 
     556               WRITE(cl_nerror,*) tm_logger%i_maxerror 
     557               CALL logger_fatal(& 
     558               &  'Error count reached limit of '//TRIM(ADJUSTL(cl_nerror)) ) 
     559            ENDIF 
     560         ELSE 
     561             CALL logger_open('logger.log') 
     562             CALL logger_header() 
     563             CALL logger_fatal('you must have create logger to use logger_error') 
     564         ENDIF 
     565      ENDIF 
    511566   END SUBROUTINE logger_error 
    512    ! @endcode    
    513567   !------------------------------------------------------------------- 
    514568   !> @brief This subroutine write fatal error message on log file,  
    … …  
    516570   !> 
    517571   !> @author J.Paul 
    518    !> - Nov, 2013- Initial Version 
    519    ! 
    520    !> @param[in] cd_msg : message to write 
    521    ! 
    522    !------------------------------------------------------------------- 
    523    ! @code 
     572   !> @date November, 2013 - Initial Version 
     573   ! 
     574   !> @param[in] cd_msg message to write 
     575   !------------------------------------------------------------------- 
    524576   RECURSIVE SUBROUTINE logger_fatal(cd_msg) 
    525577      IMPLICIT NONE 
    … …  
    527579      CHARACTER(LEN=*),           INTENT(IN) :: cd_msg 
    528580      !---------------------------------------------------------------- 
    529       IF( tm_logger%i_id /= 0 )THEN 
    530          IF( INDEX(TRIM(tm_logger%c_verb),'fatal')/=0 )THEN 
    531             ! increment the error number 
    532             tm_logger%i_nfatal=tm_logger%i_nfatal+1 
    533  
    534             CALL logger__write("FATAL   :",cd_msg) 
    535  
    536             CALL logger_footer() 
    537             CALL logger_close() 
    538  
    539             STOP 
    540          ENDIF 
    541       ELSE 
    542           CALL logger_open('logger.log') 
    543           CALL logger_header() 
    544           CALL logger_fatal('you must have create logger to use logger_fatal') 
     581      IF( tm_logger%l_use )THEN 
     582         IF( tm_logger%i_id /= 0 )THEN 
     583            IF( INDEX(TRIM(tm_logger%c_verb),'fatal')/=0 )THEN 
     584               ! increment the error number 
     585               tm_logger%i_nfatal=tm_logger%i_nfatal+1 
     586 
     587               CALL logger__write("FATAL   :",cd_msg) 
     588 
     589               CALL logger_footer() 
     590               CALL logger_close() 
     591 
     592               WRITE(*,*) 'FATAL ERROR' 
     593               STOP 
     594            ENDIF 
     595         ELSE 
     596             CALL logger_open('logger.log') 
     597             CALL logger_header() 
     598             CALL logger_fatal('you must have create logger to use logger_fatal') 
     599         ENDIF 
    545600      ENDIF 
    546601   END SUBROUTINE logger_fatal 
    547    ! @endcode    
    548602   !------------------------------------------------------------------- 
    549603   !> @brief This subroutine cut message to get maximum of 80 character  
    … …  
    551605   !> 
    552606   !> @author J.Paul 
    553    !> - Nov, 2013- Initial Version 
    554    ! 
    555    !> @param[in] cd_verb : verbosity of the message to write 
    556    !> @param[in] cd_msg : message to write 
    557    !------------------------------------------------------------------- 
    558    ! @code 
     607   !> @date November, 2013 - Initial Version 
     608   ! 
     609   !> @param[in] cd_verb   verbosity of the message to write 
     610   !> @param[in] cd_msg    message to write 
     611   !------------------------------------------------------------------- 
    559612   SUBROUTINE logger__write(cd_verb, cd_msg) 
    560613      IMPLICIT NONE 
    … …  
    602655 
    603656   END SUBROUTINE logger__write 
    604    ! @endcode    
     657   !------------------------------------------------------------------- 
     658   !> @brief This function check validity of verbosity. 
     659   !> 
     660   !> @author J.Paul 
     661   !> @date February, 2015 - Initial Version 
     662   ! 
     663   !> @param[in] cd_verb   verbosity of the message to write 
     664   !> @return verbosity is valid or not 
     665   !------------------------------------------------------------------- 
     666   FUNCTION logger__check_verb(cd_verb) 
     667      IMPLICIT NONE 
     668      ! Argument 
     669      CHARACTER(LEN=*),           INTENT(IN) :: cd_verb 
     670 
     671      !function 
     672      LOGICAL           :: logger__check_verb 
     673 
     674      ! local variable 
     675      ! loop indices 
     676      INTEGER(i4) :: ji 
     677 
     678      !---------------------------------------------------------------- 
     679      logger__check_verb=.FALSE. 
     680 
     681      DO ji=1,im_nverbosity 
     682         IF( TRIM(cd_verb) == TRIM(cm_verbosity(ji)) )THEN 
     683            logger__check_verb=.TRUE. 
     684            EXIT 
     685         ENDIF 
     686      ENDDO 
     687 
     688      IF( .NOT. logger__check_verb )THEN 
     689         CALL logger_open('logger.log') 
     690         CALL logger_header() 
     691         CALL logger_fatal('LOGGER : invalid verbosity, check namelist.'//& 
     692         &                 ' default one will be used.') 
     693         CALL logger_footer() 
     694      ENDIF 
     695   END FUNCTION logger__check_verb 
    605696END MODULE logger 
    606697 
Note: See TracChangeset for help on using the changeset viewer.