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 10251 for branches/UKMO/dev_r5518_AMM15_package/NEMOGCM/TOOLS/SIREN/src/logger.f90 – NEMO

Ignore:
Timestamp:
2018-10-29T15:20:26+01:00 (5 years ago)
Author:
kingr
Message:

Rolled back to r10247 - i.e., undid merge of pkg br and 3.6_stable br

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/UKMO/dev_r5518_AMM15_package/NEMOGCM/TOOLS/SIREN/src/logger.f90

    r10248 r10251  
    1616!> but not necessarily "wrong".  
    1717!>    - error : Other runtime errors or unexpected conditions. 
    18 !>    - fatal : Severe errors that cause premature termination. 
     18!>    - fatal : Severe errors that cause premature termination.<br /> 
    1919!>  default verbosity is warning 
    20 !>    - none  : to not create and write any information in logger file.<br /> 
    2120! 
    2221!> If total number of error exceeded maximum number  
     
    2524!> to open/create logger file:<br/> 
    2625!> @code 
    27 !>    CALL logger_open(cd_file, [cd_verbosity,] [id_maxerror,] [id_loggerid]) 
     26!>    CALL logger_open(cd_file, [cd_verbosity,] [id_loggerid,] [id_maxerror]) 
    2827!> @endcode 
    2928!> - cd_file is logger file name 
     
    121120!> J.Paul 
    122121! REVISION HISTORY: 
    123 !> @date November, 2013 - Initial Version 
    124 !> @date February, 2015 
    125 !> - check verbosity validity 
    126 !> - add 'none' verbosity level to not used logger file 
     122!> @date November, 2013- Initial Version 
    127123!> 
    128124!> @note Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt) 
     
    155151 
    156152   PRIVATE :: logger__write     ! cut message to get maximum of 80 character by line in log file 
    157    PRIVATE :: logger__check_verb! check verbosity validity 
    158153 
    159154   TYPE TLOGGER   !< logger structure 
    160155      INTEGER(i4)       :: i_id = 0                 !< log file id 
    161       LOGICAL           :: l_use=.TRUE.             !< use logger or not 
    162156      CHARACTER(LEN=lc) :: c_name                   !< log file name 
    163157      CHARACTER(LEN=lc) :: c_verbosity = "warning"  !< verbosity choose 
     
    169163 
    170164   !  module variable 
    171    INTEGER(i4), PARAMETER :: im_nverbosity=7     !< number of log level 
     165   INTEGER(i4), PARAMETER :: im_nverbosity=6     !< number of log level 
    172166   CHARACTER(len=*), DIMENSION(im_nverbosity), PARAMETER :: cm_verbosity= & !< verbosity array  
    173167   &               (/ 'trace   ',& 
     
    176170   &                  'warning ',& 
    177171   &                  'error   ',& 
    178    &                  'fatal   ',& 
    179    &                  'none    '/) 
     172   &                  'fatal   '/) 
    180173 
    181174   TYPE(TLOGGER), SAVE :: tm_logger      !< logger structure 
     
    191184   !> 
    192185   !> @author J.Paul 
    193    !> @date November, 2013 - Initial Version 
     186   !> - November, 2013- Initial Version 
    194187   ! 
    195188   !> @param[in] cd_file      log file name 
    196189   !> @param[in] cd_verbosity log file verbosity 
     190   !> @param[in] id_logid     log file id (use to flush) 
    197191   !> @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) 
     192   !------------------------------------------------------------------- 
     193   SUBROUTINE logger_open(cd_file, cd_verbosity, id_logid, id_maxerror) 
    201194      IMPLICIT NONE 
    202195      ! Argument 
    203196      CHARACTER(len=*), INTENT(IN) :: cd_file                ! log file name 
    204197      CHARACTER(len=*), INTENT(IN), OPTIONAL :: cd_verbosity ! log file verbosity 
     198      INTEGER(i4),      INTENT(IN), OPTIONAL :: id_logid     ! log file id 
    205199      INTEGER(i4),      INTENT(IN), OPTIONAL :: id_maxerror  ! log max error 
    206       INTEGER(i4),      INTENT(IN), OPTIONAL :: id_logid     ! log file id 
    207200 
    208201      ! local variable 
    209202      INTEGER(i4) :: il_status 
    210203 
    211       LOGICAL     :: ll_valid 
    212  
    213204      ! loop 
    214205      INTEGER(i4) :: ji 
    215206      !---------------------------------------------------------------- 
     207      ! get id if not already define 
     208      IF( PRESENT(id_logid) )THEN 
     209         tm_logger%i_id=id_logid 
     210      ELSE 
     211         tm_logger%i_id=fct_getunit() 
     212      ENDIF 
     213 
     214      ! open log file 
     215      OPEN( tm_logger%i_id, & 
     216      &     STATUS="unknown",    & 
     217      &     FILE=TRIM(ADJUSTL(cd_file)),  & 
     218      &     ACTION="write",      & 
     219      &     POSITION="append",   & 
     220      &     IOSTAT=il_status) 
     221      CALL fct_err(il_status) 
     222 
     223      ! keep filename 
     224      tm_logger%c_name=TRIM(ADJUSTL(cd_file)) 
    216225 
    217226      ! if present, change verbosity value 
    218227      IF( PRESENT(cd_verbosity) )THEN 
    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  
     228         tm_logger%c_verbosity=TRIM(ADJUSTL(cd_verbosity)) 
     229      ENDIF 
     230 
     231      ! compute "tab" of verbosity to be used 
     232      IF( TRIM(ADJUSTL(tm_logger%c_verb)) == "" )THEN 
     233         DO ji=im_nverbosity,1,-1 
     234            tm_logger%c_verb = & 
     235            &  TRIM(tm_logger%c_verb)//" "//TRIM(ADJUSTL(cm_verbosity(ji))) 
     236            IF( TRIM(tm_logger%c_verbosity) == TRIM(cm_verbosity(ji)) )THEN 
     237               EXIT 
     238            ENDIF 
     239         ENDDO 
     240      ENDIF 
     241 
     242      IF( PRESENT(id_maxerror) )THEN 
     243         tm_logger%i_maxerror=id_maxerror 
    263244      ENDIF 
    264245 
     
    268249   !> 
    269250   !> @author J.Paul 
    270    !> @date November, 2013 - Initial Version 
     251   !> - November, 2013- Initial Version 
    271252   !------------------------------------------------------------------- 
    272253   SUBROUTINE logger_close() 
     
    275256      INTEGER(i4) :: il_status 
    276257      !---------------------------------------------------------------- 
    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 
     258      IF( tm_logger%i_id /= 0 )THEN 
     259         tm_logger%i_id = 0 
     260         CLOSE( tm_logger%i_id, & 
     261         &      IOSTAT=il_status)       
     262         CALL fct_err(il_status) 
     263      ELSE 
     264          CALL logger_open('logger.log') 
     265          CALL logger_header() 
     266          CALL logger_fatal('you must have create logger to use logger_close') 
    288267      ENDIF 
    289268 
     
    293272   !> 
    294273   !> @author J.Paul 
    295    !> @date November, 2013 - Initial Version 
     274   !> - November, 2013- Initial Version 
    296275   !------------------------------------------------------------------- 
    297276   SUBROUTINE logger_flush() 
    298277      IMPLICIT NONE 
    299278      !---------------------------------------------------------------- 
    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 
     279      IF( tm_logger%i_id /= 0 )THEN 
     280         CALL logger_close() 
     281         CALL logger_open( tm_logger%c_name, tm_logger%c_verbosity, tm_logger%i_id, & 
     282         &              tm_logger%i_maxerror )      
     283      ELSE 
     284          CALL logger_open('logger.log') 
     285          CALL logger_header() 
     286          CALL logger_fatal('you must have create logger to use logger_flush') 
    310287      ENDIF 
    311288 
     
    315292   !> 
    316293   !> @author J.Paul 
    317    !> @date November, 2013 - Initial Version 
     294   !> - November, 2013- Initial Version 
    318295   !------------------------------------------------------------------- 
    319296   RECURSIVE SUBROUTINE logger_header() 
     
    322299      INTEGER(i4)       :: il_status 
    323300      !---------------------------------------------------------------- 
    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 
     301      IF( tm_logger%i_id /= 0 )THEN 
     302         WRITE( tm_logger%i_id,    & 
     303            &   FMT='(4(a/))',     & 
     304            &   IOSTAT=il_status ) & 
     305            &   "--------------------------------------------------",& 
     306            &   "INIT     : verbosity "//TRIM(tm_logger%c_verbosity),& 
     307            &   "INIT     : max error "//TRIM(fct_str(tm_logger%i_maxerror)), & 
     308            &   "--------------------------------------------------" 
     309         CALL fct_err(il_status) 
     310      ELSE 
     311          CALL logger_open('logger.log') 
     312          CALL logger_header() 
     313          CALL logger_fatal('you must have create logger to use logger_header') 
    339314      ENDIF 
    340315 
     
    344319   !> 
    345320   !> @author J.Paul 
    346    !> @date November, 2013 - Initial Version 
     321   !> - November, 2013- Initial Version 
    347322   !------------------------------------------------------------------- 
    348323   SUBROUTINE logger_footer() 
     
    351326      INTEGER(i4)       :: il_status 
    352327      !---------------------------------------------------------------- 
    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 
     328      IF( tm_logger%i_id /= 0 )THEN 
     329         WRITE( tm_logger%i_id,    & 
     330            &   FMT='(4(/a))',     & 
     331            &   IOSTAT=il_status ) & 
     332            &   "--------------------------------------------------",& 
     333            &   "END      : log ended ",              & 
     334            &   "END      : "//TRIM(fct_str(tm_logger%i_nerror))//   & 
     335            &   " ERROR detected ",                                  & 
     336            &   "END      : "//TRIM(fct_str(tm_logger%i_nfatal))//   & 
     337            &   " FATAL detected ",                                  & 
     338            &   "--------------------------------------------------" 
     339         CALL fct_err(il_status) 
     340      ELSE 
     341          CALL logger_open('logger.log') 
     342          CALL logger_header() 
     343          CALL logger_fatal('you must have create logger to use logger_footer') 
    371344      ENDIF 
    372345   END SUBROUTINE logger_footer 
     
    377350   !> 
    378351   !> @author J.Paul 
    379    !> @date November, 2013 - Initial Version 
     352   !> - November, 2013- Initial Version 
    380353   ! 
    381354   !> @param[in] cd_msg    message to write 
     
    388361      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush 
    389362      !---------------------------------------------------------------- 
    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') 
     363      IF( tm_logger%i_id /= 0 )THEN 
     364         IF( INDEX(TRIM(tm_logger%c_verb),'trace')/=0 )THEN 
     365 
     366            CALL logger__write("TRACE   :",cd_msg) 
     367 
     368            IF( PRESENT(ld_flush) )THEN 
     369               IF( ld_flush )THEN 
     370                  CALL logger_flush() 
     371               ENDIF 
     372            ENDIF       
    406373         ENDIF 
     374      ELSE 
     375          CALL logger_open('logger.log') 
     376          CALL logger_header() 
     377          CALL logger_fatal('you must have create logger to use logger_trace') 
    407378      ENDIF 
    408379   END SUBROUTINE logger_trace 
     
    413384   !> 
    414385   !> @author J.Paul 
    415    !> @date November, 2013 - Initial Version 
     386   !> - November, 2013- Initial Version 
    416387   ! 
    417388   !> @param[in] cd_msg    message to write 
     
    424395      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush 
    425396      !---------------------------------------------------------------- 
    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') 
     397      IF( tm_logger%i_id /= 0 )THEN 
     398         IF( INDEX(TRIM(tm_logger%c_verb),'debug')/=0 )THEN 
     399 
     400            CALL logger__write("DEBUG   :",cd_msg) 
     401 
     402            IF( PRESENT(ld_flush) )THEN 
     403               IF( ld_flush )THEN 
     404                  CALL logger_flush() 
     405               ENDIF 
     406            ENDIF       
    442407         ENDIF 
     408      ELSE 
     409          CALL logger_open('logger.log') 
     410          CALL logger_header() 
     411          CALL logger_fatal('you must have create logger to use logger_debug') 
    443412      ENDIF 
    444413   END SUBROUTINE logger_debug 
     
    449418   !> 
    450419   !> @author J.Paul 
    451    !> @date November, 2013 - Initial Version 
     420   !> - November, 2013- Initial Version 
    452421   ! 
    453422   !> @param[in] cd_msg    message to write 
     
    460429      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush 
    461430      !---------------------------------------------------------------- 
    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') 
     431      IF( tm_logger%i_id /= 0 )THEN 
     432         IF( INDEX(TRIM(tm_logger%c_verb),'info')/=0 )THEN 
     433 
     434            CALL logger__write("INFO    :",cd_msg) 
     435 
     436            IF( PRESENT(ld_flush) )THEN 
     437               IF( ld_flush )THEN 
     438                  CALL logger_flush() 
     439               ENDIF 
     440            ENDIF       
    478441         ENDIF 
     442      ELSE 
     443          CALL logger_open('logger.log') 
     444          CALL logger_header() 
     445          CALL logger_fatal('you must have create logger to use logger_info') 
    479446      ENDIF 
    480447   END SUBROUTINE logger_info 
     
    485452   !> 
    486453   !> @author J.Paul 
    487    !> @date November, 2013 - Initial Version 
     454   !> - November, 2013- Initial Version 
    488455   ! 
    489456   !> @param[in] cd_msg    message to write 
     
    496463      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush 
    497464      !---------------------------------------------------------------- 
    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') 
     465      IF( tm_logger%i_id /= 0 )THEN 
     466         IF( INDEX(TRIM(tm_logger%c_verb),'warn')/=0 )THEN 
     467 
     468            CALL logger__write("WARNING :",cd_msg) 
     469 
     470            IF( PRESENT(ld_flush) )THEN 
     471               IF( ld_flush )THEN 
     472                  CALL logger_flush() 
     473               ENDIF 
     474            ENDIF       
    514475         ENDIF 
     476      ELSE 
     477          CALL logger_open('logger.log') 
     478          CALL logger_header() 
     479          CALL logger_fatal('you must have create logger to use logger_warn') 
    515480      ENDIF 
    516481   END SUBROUTINE logger_warn 
     
    521486   !> 
    522487   !> @author J.Paul 
    523    !> @date November, 2013 - Initial Version 
     488   !> - November, 2013- Initial Version 
    524489   ! 
    525490   !> @param[in] cd_msg    message to write 
     
    535500      CHARACTER(LEN=lc) :: cl_nerror 
    536501      !---------------------------------------------------------------- 
    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') 
     502      IF( tm_logger%i_id /= 0 )THEN 
     503         ! increment the error number 
     504         tm_logger%i_nerror=tm_logger%i_nerror+1 
     505 
     506         IF( INDEX(TRIM(tm_logger%c_verb),'error')/=0 )THEN 
     507 
     508            CALL logger__write("ERROR   :",cd_msg) 
     509 
     510            IF( PRESENT(ld_flush) )THEN 
     511               IF( ld_flush )THEN 
     512                  CALL logger_flush() 
     513               ENDIF 
     514            ENDIF       
    564515         ENDIF 
    565       ENDIF 
     516 
     517         IF( tm_logger%i_nerror >= tm_logger%i_maxerror )THEN 
     518            WRITE(cl_nerror,*) tm_logger%i_maxerror 
     519            CALL logger_fatal(& 
     520            &  'Error count reached limit of '//TRIM(ADJUSTL(cl_nerror)) ) 
     521         ENDIF 
     522      ELSE 
     523          CALL logger_open('logger.log') 
     524          CALL logger_header() 
     525          CALL logger_fatal('you must have create logger to use logger_error') 
     526      ENDIF 
     527 
    566528   END SUBROUTINE logger_error 
    567529   !------------------------------------------------------------------- 
     
    570532   !> 
    571533   !> @author J.Paul 
    572    !> @date November, 2013 - Initial Version 
     534   !> - November, 2013- Initial Version 
    573535   ! 
    574536   !> @param[in] cd_msg message to write 
     
    579541      CHARACTER(LEN=*),           INTENT(IN) :: cd_msg 
    580542      !---------------------------------------------------------------- 
    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') 
     543      IF( tm_logger%i_id /= 0 )THEN 
     544         IF( INDEX(TRIM(tm_logger%c_verb),'fatal')/=0 )THEN 
     545            ! increment the error number 
     546            tm_logger%i_nfatal=tm_logger%i_nfatal+1 
     547 
     548            CALL logger__write("FATAL   :",cd_msg) 
     549 
     550            CALL logger_footer() 
     551            CALL logger_close() 
     552 
     553            WRITE(*,*) 'FATAL ERROR' 
     554            STOP 
    599555         ENDIF 
     556      ELSE 
     557          CALL logger_open('logger.log') 
     558          CALL logger_header() 
     559          CALL logger_fatal('you must have create logger to use logger_fatal') 
    600560      ENDIF 
    601561   END SUBROUTINE logger_fatal 
     
    605565   !> 
    606566   !> @author J.Paul 
    607    !> @date November, 2013 - Initial Version 
     567   !> - November, 2013- Initial Version 
    608568   ! 
    609569   !> @param[in] cd_verb   verbosity of the message to write 
     
    655615 
    656616   END SUBROUTINE logger__write 
    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 
    696617END MODULE logger 
    697618 
Note: See TracChangeset for help on using the changeset viewer.