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/2014/dev_r4650_UKMO10_Tidally_Meaned_Diagnostics/NEMOGCM/TOOLS/SIREN/src – NEMO

source: branches/2014/dev_r4650_UKMO10_Tidally_Meaned_Diagnostics/NEMOGCM/TOOLS/SIREN/src/logger.f90 @ 5989

Last change on this file since 5989 was 5989, checked in by deazer, 8 years ago

Merging TMB and 25h diagnostics to head of trunk
added brief documentation

File size: 24.2 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 create logger file and allow to fill it depending of verbosity.
9!> @details
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!>  default verbosity is warning
20!>    - none  : to not create and write any information in logger file.<br />
21!
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
97!>   CALL logger_open('loggerfile.txt','info')
98!>
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
109!>   CALL logger_open('loggerfile.txt')
110!>
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
119!
120!> @author
121!> J.Paul
122! 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
127!>
128!> @note Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt)
129!----------------------------------------------------------------------
130MODULE logger
131   USE kind                            ! F90 kind parameter
132   USE fct                             ! basic useful function
133   IMPLICIT NONE
134   ! NOTE_avoid_public_variables_if_possible
135
136   ! type and variable
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
142
143   ! function and subroutine
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
155
156   PRIVATE :: logger__write     ! cut message to get maximum of 80 character by line in log file
157   PRIVATE :: logger__check_verb! check verbosity validity
158
159   TYPE TLOGGER   !< logger structure
160      INTEGER(i4)       :: i_id = 0                 !< log file id
161      LOGICAL           :: l_use=.TRUE.             !< use logger or not
162      CHARACTER(LEN=lc) :: c_name                   !< log file name
163      CHARACTER(LEN=lc) :: c_verbosity = "warning"  !< verbosity choose
164      CHARACTER(LEN=lc) :: c_verb = ""              !< array of "verbosities" to used
165      INTEGER(i4)       :: i_nerror   = 0           !< number of error
166      INTEGER(i4)       :: i_nfatal   = 0           !< number of fatal error
167      INTEGER(i4)       :: i_maxerror = 5           !< maximum number of error before stoping program
168   END TYPE TLOGGER   
169
170   !  module variable
171   INTEGER(i4), PARAMETER :: im_nverbosity=7     !< number of log level
172   CHARACTER(len=*), DIMENSION(im_nverbosity), PARAMETER :: cm_verbosity= & !< verbosity array
173   &               (/ 'trace   ',&
174   &                  'debug   ',&
175   &                  'info    ',& 
176   &                  'warning ',&
177   &                  'error   ',&
178   &                  'fatal   ',&
179   &                  'none    '/)
180
181   TYPE(TLOGGER), SAVE :: tm_logger      !< logger structure
182                                                 
183CONTAINS
184   !-------------------------------------------------------------------
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)
201      IMPLICIT NONE
202      ! Argument
203      CHARACTER(len=*), INTENT(IN) :: cd_file                ! log file name
204      CHARACTER(len=*), INTENT(IN), OPTIONAL :: cd_verbosity ! log file verbosity
205      INTEGER(i4),      INTENT(IN), OPTIONAL :: id_maxerror  ! log max error
206      INTEGER(i4),      INTENT(IN), OPTIONAL :: id_logid     ! log file id
207
208      ! local variable
209      INTEGER(i4) :: il_status
210
211      LOGICAL     :: ll_valid
212
213      ! loop
214      INTEGER(i4) :: ji
215      !----------------------------------------------------------------
216
217      ! if present, change verbosity value
218      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
263      ENDIF
264
265   END SUBROUTINE logger_open
266   !-------------------------------------------------------------------
267   !> @brief This subroutine close a log file.
268   !>
269   !> @author J.Paul
270   !> @date November, 2013 - Initial Version
271   !-------------------------------------------------------------------
272   SUBROUTINE logger_close()
273      IMPLICIT NONE
274      ! local variable
275      INTEGER(i4) :: il_status
276      !----------------------------------------------------------------
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
288      ENDIF
289
290   END SUBROUTINE logger_close
291   !-------------------------------------------------------------------
292   !> @brief This subroutine flushing output into log file.
293   !>
294   !> @author J.Paul
295   !> @date November, 2013 - Initial Version
296   !-------------------------------------------------------------------
297   SUBROUTINE logger_flush()
298      IMPLICIT NONE
299      !----------------------------------------------------------------
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
310      ENDIF
311
312   END SUBROUTINE logger_flush
313   !-------------------------------------------------------------------
314   !> @brief This subroutine write header on log file.
315   !>
316   !> @author J.Paul
317   !> @date November, 2013 - Initial Version
318   !-------------------------------------------------------------------
319   RECURSIVE SUBROUTINE logger_header()
320      IMPLICIT NONE
321      ! local variable
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
339      ENDIF
340
341   END SUBROUTINE logger_header
342   !-------------------------------------------------------------------
343   !> @brief This subroutine write footer on log file.
344   !>
345   !> @author J.Paul
346   !> @date November, 2013 - Initial Version
347   !-------------------------------------------------------------------
348   SUBROUTINE logger_footer()
349      IMPLICIT NONE
350      ! local variable
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
371      ENDIF
372   END SUBROUTINE logger_footer
373   !-------------------------------------------------------------------
374   !> @brief This subroutine write trace message on log file.
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   !-------------------------------------------------------------------
384   SUBROUTINE logger_trace(cd_msg, ld_flush)
385      IMPLICIT NONE
386      ! Argument
387      CHARACTER(LEN=*), INTENT(IN)  :: cd_msg
388      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush
389      !----------------------------------------------------------------
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
407      ENDIF
408   END SUBROUTINE logger_trace
409   !-------------------------------------------------------------------
410   !> @brief This subroutine write debug message on log file.
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   !-------------------------------------------------------------------
420   SUBROUTINE logger_debug(cd_msg, ld_flush)
421      IMPLICIT NONE
422      ! Argument
423      CHARACTER(LEN=*), INTENT(IN)  :: cd_msg
424      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush
425      !----------------------------------------------------------------
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
443      ENDIF
444   END SUBROUTINE logger_debug
445   !-------------------------------------------------------------------
446   !> @brief This subroutine write info message on log file.
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   !-------------------------------------------------------------------
456   SUBROUTINE logger_info(cd_msg, ld_flush)
457      IMPLICIT NONE
458      ! Argument
459      CHARACTER(LEN=*), INTENT(IN)  :: cd_msg
460      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush
461      !----------------------------------------------------------------
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
479      ENDIF
480   END SUBROUTINE logger_info
481   !-------------------------------------------------------------------
482   !> @brief This subroutine write warning message on log file.
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   !-------------------------------------------------------------------
492   SUBROUTINE logger_warn(cd_msg, ld_flush)
493      IMPLICIT NONE
494      ! Argument
495      CHARACTER(LEN=*), INTENT(IN)  :: cd_msg
496      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush
497      !----------------------------------------------------------------
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
515      ENDIF
516   END SUBROUTINE logger_warn
517   !-------------------------------------------------------------------
518   !> @brief This subroutine write error message on log file.
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   !-------------------------------------------------------------------
528   SUBROUTINE logger_error(cd_msg, ld_flush)
529      IMPLICIT NONE
530      ! Argument
531      CHARACTER(LEN=*), INTENT(IN)  :: cd_msg
532      LOGICAL,          INTENT(IN), OPTIONAL :: ld_flush
533
534      ! local variable
535      CHARACTER(LEN=lc) :: cl_nerror
536      !----------------------------------------------------------------
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
566   END SUBROUTINE logger_error
567   !-------------------------------------------------------------------
568   !> @brief This subroutine write fatal error message on log file,
569   !> close log file and stop process.
570   !>
571   !> @author J.Paul
572   !> @date November, 2013 - Initial Version
573   !
574   !> @param[in] cd_msg message to write
575   !-------------------------------------------------------------------
576   RECURSIVE SUBROUTINE logger_fatal(cd_msg)
577      IMPLICIT NONE
578      ! Argument
579      CHARACTER(LEN=*),           INTENT(IN) :: cd_msg
580      !----------------------------------------------------------------
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
600      ENDIF
601   END SUBROUTINE logger_fatal
602   !-------------------------------------------------------------------
603   !> @brief This subroutine cut message to get maximum of 80 character
604   !> by line in log file.
605   !>
606   !> @author J.Paul
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   !-------------------------------------------------------------------
612   SUBROUTINE logger__write(cd_verb, cd_msg)
613      IMPLICIT NONE
614      ! Argument
615      CHARACTER(LEN=*),           INTENT(IN) :: cd_verb
616      CHARACTER(LEN=*),           INTENT(IN) :: cd_msg
617
618      ! local variable
619      INTEGER(i4)       :: il_status
620      INTEGER(i4)       :: il_verb
621      INTEGER(i4)       :: il_msg
622      CHARACTER(LEN=lc) :: cl_verb
623      CHARACTER(LEN=lc) :: cl_msg
624      CHARACTER(LEN=lc) :: cl_tmp
625
626      !----------------------------------------------------------------
627      cl_verb=TRIM(ADJUSTL(cd_verb))
628      cl_msg=TRIM(ADJUSTL(cd_msg))
629
630      il_verb=LEN_TRIM(cl_verb)
631      il_msg=LEN_TRIM(cl_msg)
632      DO WHILE( il_verb + il_msg > 78 )
633         cl_tmp=TRIM(cl_verb)//' '//TRIM(cl_msg(1:78-il_verb))
634
635         WRITE( tm_logger%i_id,  &
636         &      FMT=*,           &
637         &      IOSTAT=il_status &
638         &      ) TRIM(cl_tmp)
639         CALL fct_err(il_status)
640
641
642         cl_msg=cl_msg(78-il_verb+1:il_msg)
643         cl_verb="        :"
644
645         il_msg=LEN_TRIM(cl_msg)
646
647      ENDDO
648
649      cl_tmp=TRIM(cl_verb)//' '//TRIM(cl_msg)
650      WRITE( tm_logger%i_id,  &
651      &      FMT=*,           &
652      &      IOSTAT=il_status &
653      &      ) TRIM(cl_tmp)
654      CALL fct_err(il_status)
655
656   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
696END MODULE logger
697
Note: See TracBrowser for help on using the repository browser.