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.
logger.f90 in branches/2015/dev_r5003_MERCATOR6_CRS/NEMOGCM/TOOLS/SIREN/src – NEMO

source: branches/2015/dev_r5003_MERCATOR6_CRS/NEMOGCM/TOOLS/SIREN/src/logger.f90 @ 7261

Last change on this file since 7261 was 7261, checked in by cbricaud, 7 years ago

phaze the rest of NEMOGCM directory ( all except NEMO directory) of the CRS branch with nemo_v3_6_STABLE branch at rev 7213 (09-09-2016) (merge -r 5519:7213 )

File size: 25.1 KB
Line 
1!----------------------------------------------------------------------
2! NEMO system team, System and Interface for oceanic RElocable Nesting
3!----------------------------------------------------------------------
4!
5! MODULE: logger
6!
7! DESCRIPTION:
8!> @brief This module manage log file.
9!> @details
10!> This module create log file and fill it depending of verbosity.
11!>
12!> verbosity could be choosen between :
13!>    - trace : Most detailed information.
14!>    - debug : Detailed information on the flow through the system.
15!>    - info  : Interesting runtime events (startup/shutdown).
16!>    - warning: Use of deprecated APIs, poor use of API, 'almost' errors,
17!> other runtime situations that are undesirable or unexpected,
18!> but not necessarily "wrong".
19!>    - error : Other runtime errors or unexpected conditions.
20!>    - fatal : Severe errors that cause premature termination.
21!>    - none  : to not create and write any information in logger file.<br />
22!>       @warn in this case only FATAL ERROR will be detected.<br />
23!>
24!> @note default verbosity is warning
25!>
26!> If total number of error exceeded maximum number
27!> authorized, program stop.
28!>
29!> to open/create logger file:<br/>
30!> @code
31!>    CALL logger_open(cd_file, [cd_verbosity,] [id_maxerror,] [id_loggerid])
32!> @endcode
33!> - cd_file is logger file name
34!> - cd_verbosity is verbosity to be used [optional, default 'warning']
35!> - id_loggerid is file id [optional, use only to flush]
36!> - id_maxerror is the maximum number of error authorized before program stop [optional, default 5]
37!>
38!> to close logger file:<br/>
39!> @code
40!> CALL logger_close()
41!> @endcode
42!>
43!> to clean logger file:<br/>
44!> @code
45!> CALL logger_clean()
46!> @endcode
47!>
48!> to write header in logger file:<br/>
49!> @code
50!> CALL logger_header()
51!> @endcode
52!>
53!> to write footer in logger file:<br/>
54!> @code
55!> CALL logger_footer()
56!> @endcode
57!>
58!> to flushing output:<br/>
59!> @code
60!> CALL logger_flush()
61!> @endcode
62!>
63!> to write TRACE message in logger file:<br/>
64!> @code
65!> CALL logger_trace(cd_msg [,ld_flush])
66!> @endcode
67!>    - cd_msg is TRACE message
68!>    - ld_flush to flush output [optional]
69!>
70!> to write DEBUG message in logger file:<br/>
71!> @code
72!> CALL logger_debug(cd_msg [,ld_flush])
73!> @endcode
74!>    - cd_msg is DEBUG message
75!>    - ld_flush to flush output [optional]
76!>
77!> to write INFO message in logger file:<br/>
78!> @code
79!> CALL logger_info(cd_msg [,ld_flush])
80!> @endcode
81!>    - cd_msg is INFO message
82!>    - ld_flush to flush output [optional]
83!>
84!> to write WARNING message in logger file:<br/>
85!> @code
86!> CALL logger_warn(cd_msg [,ld_flush])
87!> @endcode
88!>    - cd_msg is WARNING message
89!>    - ld_flush to flush output [optional]
90!>
91!> to write ERROR message in logger file:<br/>
92!> @code
93!> CALL logger_error(cd_msg [,ld_flush])
94!> @endcode
95!>    - cd_msg is ERROR message
96!>    - ld_flush to flush output [optional]
97!>
98!> to write FATAL message in logger file:<br/>
99!> @code
100!> CALL logger_fatal(cd_msg)
101!> @endcode
102!>    - cd_msg is FATAL message
103!>
104!> Examples :<br />
105!> @code
106!>   CALL logger_open('loggerfile.txt','info')
107!>
108!>   CALL logger_header()
109!>   CALL logger_debug('une info de debug')
110!>   CALL logger_info('une info')
111!>   CALL logger_warn('un warning')
112!>   CALL logger_error('une erreur')
113!>   CALL logger_footer()
114!>   CALL logger_close()
115!>   CALL logger_clean()
116!> @endcode
117!>
118!> @code
119!>   CALL logger_open('loggerfile.txt')
120!>
121!>   CALL logger_header()
122!>   CALL logger_debug('une info de debug')
123!>   CALL logger_info('une info')
124!>   CALL logger_warn('un warning')
125!>   CALL logger_error('une erreur')
126!>   CALL logger_footer()
127!>   CALL logger_close()
128!>   CALL logger_clean()
129!> @endcode
130!
131!> @author
132!> J.Paul
133! REVISION HISTORY:
134!> @date November, 2013 - Initial Version
135!> @date February, 2015
136!> - check verbosity validity
137!> - add 'none' verbosity level to not used logger file
138!> @date January, 2016
139!> - add logger_clean subroutine
140!>
141!> @note Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt)
142!----------------------------------------------------------------------
143MODULE logger
144   USE kind                            ! F90 kind parameter
145   USE fct                             ! basic useful function
146   IMPLICIT NONE
147   ! NOTE_avoid_public_variables_if_possible
148
149   ! type and variable
150   PRIVATE :: TLOGGER            !< logger structure
151
152   PRIVATE :: tm_logger          !< logger structure
153   PRIVATE :: im_nverbosity      !< number of log level
154   PRIVATE :: cm_verbosity       !< verbosity array
155
156   ! function and subroutine
157   PUBLIC :: logger_open        !< create a log file with given verbosity
158   PUBLIC :: logger_close       !< close log file
159   PUBLIC :: logger_clean       !< clean log structure
160   PUBLIC :: logger_header      !< write header on log file
161   PUBLIC :: logger_footer      !< write footer on log file
162   PUBLIC :: logger_flush       !< flushing output
163   PUBLIC :: logger_trace       !< write trace    message in log file
164   PUBLIC :: logger_debug       !< write debug    message in log file
165   PUBLIC :: logger_info        !< write info     message in log file
166   PUBLIC :: logger_warn        !< write warning  message in log file
167   PUBLIC :: logger_error       !< write error    message in log file
168   PUBLIC :: logger_fatal       !< write fatal    message in log file, and stop
169
170   PRIVATE :: logger__write     ! cut message to get maximum of 80 character by line in log file
171   PRIVATE :: logger__check_verb! check verbosity validity
172
173   TYPE TLOGGER   !< logger structure
174      INTEGER(i4)       :: i_id = 0                 !< log file id
175      LOGICAL           :: l_use=.TRUE.             !< use logger or not
176      CHARACTER(LEN=lc) :: c_name                   !< log file name
177      CHARACTER(LEN=lc) :: c_verbosity = "warning"  !< verbosity choose
178      CHARACTER(LEN=lc) :: c_verb = ""              !< array of "verbosities" to used
179      INTEGER(i4)       :: i_nerror   = 0           !< number of error
180      INTEGER(i4)       :: i_nfatal   = 0           !< number of fatal error
181      INTEGER(i4)       :: i_maxerror = 5           !< maximum number of error before stoping program
182   END TYPE TLOGGER   
183
184   !  module variable
185   INTEGER(i4), PARAMETER :: im_nverbosity=7     !< number of log level
186   CHARACTER(len=*), DIMENSION(im_nverbosity), PARAMETER :: cm_verbosity= & !< verbosity array
187   &               (/ 'trace   ',&
188   &                  'debug   ',&
189   &                  'info    ',& 
190   &                  'warning ',&
191   &                  'error   ',&
192   &                  'fatal   ',&
193   &                  'none    '/)
194
195   TYPE(TLOGGER), SAVE :: tm_logger      !< logger structure
196                                                 
197CONTAINS
198   !-------------------------------------------------------------------
199   !> @brief This subroutine create a log file with default verbosity
200   !> ('warning').
201   !> @details
202   !> Optionally verbosity could be change to
203   !> ('trace','debug','info',warning','error','fatal').<br/>
204   !> Optionally maximum number of error allowed could be change.
205   !>
206   !> @author J.Paul
207   !> @date November, 2013 - Initial Version
208   !
209   !> @param[in] cd_file      log file name
210   !> @param[in] cd_verbosity log file verbosity
211   !> @param[in] id_maxerror  maximum number of error
212   !> @param[in] id_logid     log file id (use to flush)
213   !-------------------------------------------------------------------
214   SUBROUTINE logger_open(cd_file, cd_verbosity, id_maxerror, id_logid)
215      IMPLICIT NONE
216      ! Argument
217      CHARACTER(len=*), INTENT(IN) :: cd_file                ! log file name
218      CHARACTER(len=*), INTENT(IN), OPTIONAL :: cd_verbosity ! log file verbosity
219      INTEGER(i4),      INTENT(IN), OPTIONAL :: id_maxerror  ! log max error
220      INTEGER(i4),      INTENT(IN), OPTIONAL :: id_logid     ! log file id
221
222      ! local variable
223      INTEGER(i4) :: il_status
224
225      LOGICAL     :: ll_valid
226
227      ! loop
228      INTEGER(i4) :: ji
229      !----------------------------------------------------------------
230
231      ! if present, change verbosity value
232      IF( PRESENT(cd_verbosity) )THEN
233         ll_valid=logger__check_verb(TRIM(ADJUSTL(cd_verbosity)))
234         IF( ll_valid )THEN
235            tm_logger%c_verbosity=TRIM(ADJUSTL(cd_verbosity))
236         ENDIF
237      ENDIF
238
239      IF( TRIM(tm_logger%c_verbosity) == 'none' ) tm_logger%l_use=.FALSE.
240     
241      IF( tm_logger%l_use )THEN
242
243         ! get id if not already define
244         IF( PRESENT(id_logid) )THEN
245            tm_logger%i_id=id_logid
246         ELSE
247            tm_logger%i_id=fct_getunit()
248         ENDIF
249
250         ! open log file
251         OPEN( tm_logger%i_id, &
252         &     STATUS="unknown",    &
253         &     FILE=TRIM(ADJUSTL(cd_file)),  &
254         &     ACTION="write",      &
255         &     POSITION="append",   &
256         &     IOSTAT=il_status)
257         CALL fct_err(il_status)
258
259         ! keep filename
260         tm_logger%c_name=TRIM(ADJUSTL(cd_file))
261
262         ! compute "tab" of verbosity to be used
263         IF( TRIM(ADJUSTL(tm_logger%c_verb)) == "" )THEN
264            DO ji=im_nverbosity,1,-1
265               tm_logger%c_verb = &
266               &  TRIM(tm_logger%c_verb)//" "//TRIM(ADJUSTL(cm_verbosity(ji)))
267               IF( TRIM(tm_logger%c_verbosity) == TRIM(cm_verbosity(ji)) )THEN
268                  EXIT
269               ENDIF
270            ENDDO
271         ENDIF
272
273         IF( PRESENT(id_maxerror) )THEN
274            tm_logger%i_maxerror=id_maxerror
275         ENDIF
276
277      ENDIF
278
279   END SUBROUTINE logger_open
280   !-------------------------------------------------------------------
281   !> @brief This subroutine close a log file.
282   !>
283   !> @author J.Paul
284   !> @date November, 2013 - Initial Version
285   !-------------------------------------------------------------------
286   SUBROUTINE logger_close()
287      IMPLICIT NONE
288      ! local variable
289      INTEGER(i4)   :: il_status
290      !----------------------------------------------------------------
291      IF( tm_logger%l_use )THEN
292         IF( tm_logger%i_id /= 0 )THEN
293            !tm_logger%i_id = 0
294            CLOSE( tm_logger%i_id, &
295            &      IOSTAT=il_status)     
296            CALL fct_err(il_status)
297         ELSE
298             CALL logger_open('logger.log')
299             CALL logger_header()
300             CALL logger_fatal('you must have create logger to use logger_close')
301         ENDIF
302      ENDIF
303
304   END SUBROUTINE logger_close
305   !-------------------------------------------------------------------
306   !> @brief This subroutine clean a log structure.
307   !>
308   !> @author J.Paul
309   !> @date January, 2016 - Initial Version
310   !-------------------------------------------------------------------
311   SUBROUTINE logger_clean()
312      IMPLICIT NONE
313      ! local variable
314      TYPE(TLOGGER) :: tl_logger
315      !----------------------------------------------------------------
316      tm_logger = tl_logger
317
318   END SUBROUTINE logger_clean
319   !-------------------------------------------------------------------
320   !> @brief This subroutine flushing output into log file.
321   !>
322   !> @author J.Paul
323   !> @date November, 2013 - Initial Version
324   !-------------------------------------------------------------------
325   SUBROUTINE logger_flush()
326      IMPLICIT NONE
327      !----------------------------------------------------------------
328      IF( tm_logger%l_use )THEN
329         IF( tm_logger%i_id /= 0 )THEN
330            CALL logger_close()
331            CALL logger_open( tm_logger%c_name, tm_logger%c_verbosity, &
332            &                 tm_logger%i_maxerror, tm_logger%i_id )     
333         ELSE
334             CALL logger_open('logger.log')
335             CALL logger_header()
336             CALL logger_fatal('you must have create logger to use logger_flush')
337         ENDIF
338      ENDIF
339
340   END SUBROUTINE logger_flush
341   !-------------------------------------------------------------------
342   !> @brief This subroutine write header on log file.
343   !>
344   !> @author J.Paul
345   !> @date November, 2013 - Initial Version
346   !-------------------------------------------------------------------
347   RECURSIVE SUBROUTINE logger_header()
348      IMPLICIT NONE
349      ! local variable
350      INTEGER(i4)       :: il_status
351      !----------------------------------------------------------------
352      IF( tm_logger%l_use )THEN
353         IF( tm_logger%i_id /= 0 )THEN
354            WRITE( tm_logger%i_id,    &
355               &   FMT='(4(a/))',     &
356               &   IOSTAT=il_status ) &
357               &   "--------------------------------------------------",&
358               &   "INIT     : verbosity "//TRIM(tm_logger%c_verbosity),&
359               &   "INIT     : max error "//TRIM(fct_str(tm_logger%i_maxerror)), &
360               &   "--------------------------------------------------"
361            CALL fct_err(il_status)
362         ELSE
363             CALL logger_open('logger.log')
364             CALL logger_header()
365             CALL logger_fatal('you must have create logger to use logger_header')
366         ENDIF
367      ENDIF
368
369   END SUBROUTINE logger_header
370   !-------------------------------------------------------------------
371   !> @brief This subroutine write footer on log file.
372   !>
373   !> @author J.Paul
374   !> @date November, 2013 - Initial Version
375   !-------------------------------------------------------------------
376   SUBROUTINE logger_footer()
377      IMPLICIT NONE
378      ! local variable
379      INTEGER(i4)       :: il_status
380      !----------------------------------------------------------------
381      IF( tm_logger%l_use )THEN
382         IF( tm_logger%i_id /= 0 )THEN
383            WRITE( tm_logger%i_id,    &
384               &   FMT='(4(/a))',     &
385               &   IOSTAT=il_status ) &
386               &   "--------------------------------------------------",&
387               &   "END      : log ended ",              &
388               &   "END      : "//TRIM(fct_str(tm_logger%i_nerror))//   &
389               &   " ERROR detected ",                                  &
390               &   "END      : "//TRIM(fct_str(tm_logger%i_nfatal))//   &
391               &   " FATAL detected ",                                  &
392               &   "--------------------------------------------------"
393            CALL fct_err(il_status)
394         ELSE
395             CALL logger_open('logger.log')
396             CALL logger_header()
397             CALL logger_fatal('you must have create logger to use logger_footer')
398         ENDIF
399      ENDIF
400   END SUBROUTINE logger_footer
401   !-------------------------------------------------------------------
402   !> @brief This subroutine write trace message on log file.
403   !> @details
404   !> Optionally you could flush output.
405   !>
406   !> @author J.Paul
407   !> @date November, 2013 - Initial Version
408   !
409   !> @param[in] cd_msg    message to write
410   !> @param[in] ld_flush  flushing ouput
411   !-------------------------------------------------------------------
412   SUBROUTINE logger_trace(cd_msg, ld_flush)
413      IMPLICIT NONE
414      ! Argument
415      CHARACTER(LEN=*), INTENT(IN)  :: cd_msg
416      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush
417      !----------------------------------------------------------------
418      IF( tm_logger%l_use )THEN
419         IF( tm_logger%i_id /= 0 )THEN
420            IF( INDEX(TRIM(tm_logger%c_verb),'trace')/=0 )THEN
421
422               CALL logger__write("TRACE   :",cd_msg)
423
424               IF( PRESENT(ld_flush) )THEN
425                  IF( ld_flush )THEN
426                     CALL logger_flush()
427                  ENDIF
428               ENDIF     
429            ENDIF
430         ELSE
431             CALL logger_open('logger.log')
432             CALL logger_header()
433             CALL logger_fatal('you must have create logger to use logger_trace')
434         ENDIF
435      ENDIF
436   END SUBROUTINE logger_trace
437   !-------------------------------------------------------------------
438   !> @brief This subroutine write debug message on log file.
439   !> @details
440   !> Optionally you could flush output.
441   !>
442   !> @author J.Paul
443   !> @date November, 2013 - Initial Version
444   !
445   !> @param[in] cd_msg    message to write
446   !> @param[in] ld_flush  flushing ouput
447   !-------------------------------------------------------------------
448   SUBROUTINE logger_debug(cd_msg, ld_flush)
449      IMPLICIT NONE
450      ! Argument
451      CHARACTER(LEN=*), INTENT(IN)  :: cd_msg
452      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush
453      !----------------------------------------------------------------
454      IF( tm_logger%l_use )THEN
455         IF( tm_logger%i_id /= 0 )THEN
456            IF( INDEX(TRIM(tm_logger%c_verb),'debug')/=0 )THEN
457
458               CALL logger__write("DEBUG   :",cd_msg)
459
460               IF( PRESENT(ld_flush) )THEN
461                  IF( ld_flush )THEN
462                     CALL logger_flush()
463                  ENDIF
464               ENDIF     
465            ENDIF
466         ELSE
467             CALL logger_open('logger.log')
468             CALL logger_header()
469             CALL logger_fatal('you must have create logger to use logger_debug')
470         ENDIF
471      ENDIF
472   END SUBROUTINE logger_debug
473   !-------------------------------------------------------------------
474   !> @brief This subroutine write info message on log file.
475   !> @details
476   !> Optionally you could flush output.
477   !>
478   !> @author J.Paul
479   !> @date November, 2013 - Initial Version
480   !
481   !> @param[in] cd_msg    message to write
482   !> @param[in] ld_flush  flushing ouput
483   !-------------------------------------------------------------------
484   SUBROUTINE logger_info(cd_msg, ld_flush)
485      IMPLICIT NONE
486      ! Argument
487      CHARACTER(LEN=*), INTENT(IN)  :: cd_msg
488      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush
489      !----------------------------------------------------------------
490      IF( tm_logger%l_use )THEN
491         IF( tm_logger%i_id /= 0 )THEN
492            IF( INDEX(TRIM(tm_logger%c_verb),'info')/=0 )THEN
493
494               CALL logger__write("INFO    :",cd_msg)
495
496               IF( PRESENT(ld_flush) )THEN
497                  IF( ld_flush )THEN
498                     CALL logger_flush()
499                  ENDIF
500               ENDIF     
501            ENDIF
502         ELSE
503             CALL logger_open('logger.log')
504             CALL logger_header()
505             CALL logger_fatal('you must have create logger to use logger_info')
506         ENDIF
507      ENDIF
508   END SUBROUTINE logger_info
509   !-------------------------------------------------------------------
510   !> @brief This subroutine write warning message on log file.
511   !> @details
512   !> Optionally you could flush output.
513   !>
514   !> @author J.Paul
515   !> @date November, 2013 - Initial Version
516   !
517   !> @param[in] cd_msg    message to write
518   !> @param[in] ld_flush  flushing ouput
519   !-------------------------------------------------------------------
520   SUBROUTINE logger_warn(cd_msg, ld_flush)
521      IMPLICIT NONE
522      ! Argument
523      CHARACTER(LEN=*), INTENT(IN)  :: cd_msg
524      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush
525      !----------------------------------------------------------------
526      IF( tm_logger%l_use )THEN
527         IF( tm_logger%i_id /= 0 )THEN
528            IF( INDEX(TRIM(tm_logger%c_verb),'warn')/=0 )THEN
529
530               CALL logger__write("WARNING :",cd_msg)
531
532               IF( PRESENT(ld_flush) )THEN
533                  IF( ld_flush )THEN
534                     CALL logger_flush()
535                  ENDIF
536               ENDIF     
537            ENDIF
538         ELSE
539             CALL logger_open('logger.log')
540             CALL logger_header()
541             CALL logger_fatal('you must have create logger to use logger_warn')
542         ENDIF
543      ENDIF
544   END SUBROUTINE logger_warn
545   !-------------------------------------------------------------------
546   !> @brief This subroutine write error message on log file.
547   !> @details
548   !> Optionally you could flush output.
549   !>
550   !> @author J.Paul
551   !> @date November, 2013 - Initial Version
552   !
553   !> @param[in] cd_msg    message to write
554   !> @param[in] ld_flush  flushing ouput
555   !-------------------------------------------------------------------
556   SUBROUTINE logger_error(cd_msg, ld_flush)
557      IMPLICIT NONE
558      ! Argument
559      CHARACTER(LEN=*), INTENT(IN)  :: cd_msg
560      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush
561
562      ! local variable
563      CHARACTER(LEN=lc) :: cl_nerror
564      !----------------------------------------------------------------
565      IF( tm_logger%l_use )THEN
566         IF( tm_logger%i_id /= 0 )THEN
567            ! increment the error number
568            tm_logger%i_nerror=tm_logger%i_nerror+1
569
570            IF( INDEX(TRIM(tm_logger%c_verb),'error')/=0 )THEN
571
572               CALL logger__write("ERROR   :",cd_msg)
573
574               IF( PRESENT(ld_flush) )THEN
575                  IF( ld_flush )THEN
576                     CALL logger_flush()
577                  ENDIF
578               ENDIF     
579            ENDIF
580
581            IF( tm_logger%i_nerror >= tm_logger%i_maxerror )THEN
582               WRITE(cl_nerror,*) tm_logger%i_maxerror
583               CALL logger_fatal(&
584               &  'Error count reached limit of '//TRIM(ADJUSTL(cl_nerror)) )
585            ENDIF
586         ELSE
587             CALL logger_open('logger.log')
588             CALL logger_header()
589             CALL logger_fatal('you must have create logger to use logger_error')
590         ENDIF
591      ENDIF
592   END SUBROUTINE logger_error
593   !-------------------------------------------------------------------
594   !> @brief This subroutine write fatal error message on log file,
595   !> close log file and stop process.
596   !>
597   !> @author J.Paul
598   !> @date November, 2013 - Initial Version
599   !> @date September, 2015
600   !> - stop program for FATAL ERROR if verbosity is none
601   !
602   !> @param[in] cd_msg message to write
603   !-------------------------------------------------------------------
604   RECURSIVE SUBROUTINE logger_fatal(cd_msg)
605      IMPLICIT NONE
606      ! Argument
607      CHARACTER(LEN=*),           INTENT(IN) :: cd_msg
608      !----------------------------------------------------------------
609      IF( tm_logger%l_use )THEN
610         IF( tm_logger%i_id /= 0 )THEN
611            IF( INDEX(TRIM(tm_logger%c_verb),'fatal')/=0 )THEN
612               ! increment the error number
613               tm_logger%i_nfatal=tm_logger%i_nfatal+1
614
615               CALL logger__write("FATAL   :",cd_msg)
616
617               CALL logger_footer()
618               CALL logger_close()
619
620               WRITE(*,*) 'FATAL ERROR'
621               STOP
622            ENDIF
623         ELSE
624             CALL logger_open('logger.log')
625             CALL logger_header()
626             CALL logger_fatal('you must have create logger to use logger_fatal')
627         ENDIF
628      ELSE
629         PRINT *,"FATAL ERROR :"//TRIM(cd_msg)
630         STOP
631      ENDIF
632   END SUBROUTINE logger_fatal
633   !-------------------------------------------------------------------
634   !> @brief This subroutine cut message to get maximum of 80 character
635   !> by line in log file.
636   !>
637   !> @author J.Paul
638   !> @date November, 2013 - Initial Version
639   !
640   !> @param[in] cd_verb   verbosity of the message to write
641   !> @param[in] cd_msg    message to write
642   !-------------------------------------------------------------------
643   SUBROUTINE logger__write(cd_verb, cd_msg)
644      IMPLICIT NONE
645      ! Argument
646      CHARACTER(LEN=*),           INTENT(IN) :: cd_verb
647      CHARACTER(LEN=*),           INTENT(IN) :: cd_msg
648
649      ! local variable
650      INTEGER(i4)       :: il_status
651      INTEGER(i4)       :: il_verb
652      INTEGER(i4)       :: il_msg
653      CHARACTER(LEN=lc) :: cl_verb
654      CHARACTER(LEN=lc) :: cl_msg
655      CHARACTER(LEN=lc) :: cl_tmp
656
657      !----------------------------------------------------------------
658      cl_verb=TRIM(ADJUSTL(cd_verb))
659      cl_msg=TRIM(ADJUSTL(cd_msg))
660
661      il_verb=LEN_TRIM(cl_verb)
662      il_msg=LEN_TRIM(cl_msg)
663      DO WHILE( il_verb + il_msg > 78 )
664         cl_tmp=TRIM(cl_verb)//' '//TRIM(cl_msg(1:78-il_verb))
665
666         WRITE( tm_logger%i_id,  &
667         &      FMT=*,           &
668         &      IOSTAT=il_status &
669         &      ) TRIM(cl_tmp)
670         CALL fct_err(il_status)
671
672
673         cl_msg=cl_msg(78-il_verb+1:il_msg)
674         cl_verb="        :"
675
676         il_msg=LEN_TRIM(cl_msg)
677
678      ENDDO
679
680      cl_tmp=TRIM(cl_verb)//' '//TRIM(cl_msg)
681      WRITE( tm_logger%i_id,  &
682      &      FMT=*,           &
683      &      IOSTAT=il_status &
684      &      ) TRIM(cl_tmp)
685      CALL fct_err(il_status)
686
687   END SUBROUTINE logger__write
688   !-------------------------------------------------------------------
689   !> @brief This function check validity of verbosity.
690   !>
691   !> @author J.Paul
692   !> @date February, 2015 - Initial Version
693   !
694   !> @param[in] cd_verb   verbosity of the message to write
695   !> @return verbosity is valid or not
696   !-------------------------------------------------------------------
697   FUNCTION logger__check_verb(cd_verb)
698      IMPLICIT NONE
699      ! Argument
700      CHARACTER(LEN=*),           INTENT(IN) :: cd_verb
701
702      !function
703      LOGICAL           :: logger__check_verb
704
705      ! local variable
706      ! loop indices
707      INTEGER(i4) :: ji
708
709      !----------------------------------------------------------------
710      logger__check_verb=.FALSE.
711
712      DO ji=1,im_nverbosity
713         IF( TRIM(cd_verb) == TRIM(cm_verbosity(ji)) )THEN
714            logger__check_verb=.TRUE.
715            EXIT
716         ENDIF
717      ENDDO
718
719      IF( .NOT. logger__check_verb )THEN
720         CALL logger_open('logger.log')
721         CALL logger_header()
722         CALL logger_fatal('LOGGER : invalid verbosity, check namelist.'//&
723         &                 ' default one will be used.')
724         CALL logger_footer()
725      ENDIF
726   END FUNCTION logger__check_verb
727END MODULE logger
728
Note: See TracBrowser for help on using the repository browser.