source: utils/tools/SIREN/src/logger.f90 @ 12080

Last change on this file since 12080 was 12080, checked in by jpaul, 10 months ago

update nemo trunk

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