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 12080 for utils/tools/SIREN/src/attribute.f90 – NEMO

Ignore:
Timestamp:
2019-12-06T10:30:14+01:00 (4 years ago)
Author:
jpaul
Message:

update nemo trunk

File:
1 edited

Legend:

Unmodified
Added
Removed

  • utils/tools/SIREN/src/attribute.f90

    r9598 r12080  
    22! NEMO system team, System and Interface for oceanic RElocable Nesting 
    33!---------------------------------------------------------------------- 
    4 ! 
    5 ! MODULE: att 
    64! 
    75! DESCRIPTION: 
    … …  
    7977!> 
    8078!> @author J.Paul 
    81 ! REVISION HISTORY: 
     79!> 
    8280!> @date November, 2013 - Initial Version 
    8381!> @date November, 2014  
    … …  
    8583!> @date September, 2015 
    8684!> - manage useless (dummy) attributes 
    87 ! 
    88 !> @note Software governed by the CeCILL licence     (./LICENSE) 
     85!> @date May, 2019 
     86!> - read number of element for each dummy array in configuration file 
     87!> 
     88!> @note Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt) 
    8989!---------------------------------------------------------------------- 
    9090MODULE att 
     91 
    9192   USE netcdf                          ! nf90 library 
    9293   USE global                          ! global variable 
    … …  
    9495   USE logger                          ! log file manager 
    9596   USE fct                             ! basic useful function 
     97 
    9698   IMPLICIT NONE 
     99 
    97100   ! NOTE_avoid_public_variables_if_possible 
    98101 
    … …  
    100103   PUBLIC :: TATT       !< attribute structure 
    101104 
    102    PRIVATE :: cm_dumatt !< dummy attribute array 
     105   PRIVATE :: im_ndumatt   !< number of elt in dummy attribute array 
     106   PRIVATE :: cm_dumatt    !< dummy attribute array 
    103107 
    104108   ! function and subroutine 
    … …  
    141145   END TYPE TATT 
    142146 
    143    CHARACTER(LEN=lc), DIMENSION(ip_maxdumcfg), SAVE :: cm_dumatt !< dummy attribute 
     147   INTEGER(i4)                               , SAVE :: im_ndumatt !< number of elt in dummy attribute array 
     148   CHARACTER(LEN=lc), DIMENSION(ip_maxdumcfg), SAVE :: cm_dumatt  !< dummy attribute 
    144149 
    145150   INTERFACE att_init 
    … …  
    175180 
    176181CONTAINS 
     182   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     183   FUNCTION att__copy_arr(td_att) & 
     184         & RESULT(tf_att)       
    177185   !------------------------------------------------------------------- 
    178186   !> @brief 
    … …  
    196204   !> @return copy of input array of attribute structure 
    197205   !------------------------------------------------------------------- 
    198    FUNCTION att__copy_arr( td_att ) 
    199       IMPLICIT NONE 
    200       ! Argument 
    201       TYPE(TATT), DIMENSION(:), INTENT(IN) :: td_att 
    202       ! function 
    203       TYPE(TATT), DIMENSION(SIZE(td_att(:))) :: att__copy_arr 
     206 
     207      IMPLICIT NONE 
     208 
     209      ! Argument 
     210      TYPE(TATT), DIMENSION(:)  , INTENT(IN) :: td_att 
     211      ! function 
     212      TYPE(TATT), DIMENSION(SIZE(td_att(:))) :: tf_att 
    204213 
    205214      ! local variable 
    … …  
    209218 
    210219      DO ji=1,SIZE(td_att(:)) 
    211          att__copy_arr(ji)=att_copy(td_att(ji)) 
     220         tf_att(ji)=att_copy(td_att(ji)) 
    212221      ENDDO 
    213222 
    214223   END FUNCTION att__copy_arr 
     224   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     225   FUNCTION att__copy_unit(td_att) & 
     226         & RESULT (tf_att) 
    215227   !------------------------------------------------------------------- 
    216228   !> @brief 
    … …  
    235247   !> @return copy of input attribute structure 
    236248   !------------------------------------------------------------------- 
    237    FUNCTION att__copy_unit( td_att ) 
    238       IMPLICIT NONE 
     249 
     250      IMPLICIT NONE 
     251 
    239252      ! Argument 
    240253      TYPE(TATT), INTENT(IN)  :: td_att 
    241       ! function 
    242       TYPE(TATT) :: att__copy_unit 
     254 
     255      ! function 
     256      TYPE(TATT)              :: tf_att 
    243257 
    244258      ! local variable 
    … …  
    247261 
    248262      ! copy attribute variable 
    249       att__copy_unit%c_name  = TRIM(td_att%c_name) 
    250       att__copy_unit%i_id    = td_att%i_id 
    251       att__copy_unit%i_type  = td_att%i_type 
    252       att__copy_unit%i_len   = td_att%i_len 
    253       att__copy_unit%c_value = TRIM(td_att%c_value) 
     263      tf_att%c_name  = TRIM(td_att%c_name) 
     264      tf_att%i_id    = td_att%i_id 
     265      tf_att%i_type  = td_att%i_type 
     266      tf_att%i_len   = td_att%i_len 
     267      tf_att%c_value = TRIM(td_att%c_value) 
    254268 
    255269      ! copy attribute pointer in an independant variable 
    256       IF( ASSOCIATED(att__copy_unit%d_value) ) DEALLOCATE(att__copy_unit%d_value) 
     270      IF( ASSOCIATED(tf_att%d_value) ) DEALLOCATE(tf_att%d_value) 
    257271      IF( ASSOCIATED(td_att%d_value) )THEN 
    258272         ALLOCATE( dl_value(td_att%i_len) ) 
    259273         dl_value(:) = td_att%d_value(:) 
    260274 
    261          ALLOCATE( att__copy_unit%d_value(att__copy_unit%i_len) ) 
    262          att__copy_unit%d_value(:) = dl_value(:) 
     275         ALLOCATE( tf_att%d_value(tf_att%i_len) ) 
     276         tf_att%d_value(:) = dl_value(:) 
    263277 
    264278         DEALLOCATE( dl_value ) 
    … …  
    266280 
    267281   END FUNCTION att__copy_unit 
     282   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     283   FUNCTION att_get_index(td_att, cd_name) & 
     284         & RESULT(if_idx) 
    268285   !------------------------------------------------------------------- 
    269286   !> @brief This function return attribute index, in a array of attribute structure, 
    … …  
    279296   !> @return attribute index 
    280297   !------------------------------------------------------------------- 
    281    INTEGER(i4) FUNCTION att_get_index( td_att, cd_name ) 
    282       IMPLICIT NONE 
     298 
     299      IMPLICIT NONE 
     300 
    283301      ! Argument 
    284302      TYPE(TATT),       DIMENSION(:), INTENT(IN) :: td_att 
    285303      CHARACTER(LEN=*),               INTENT(IN) :: cd_name 
    286304 
     305      ! function 
     306      INTEGER(i4)                                :: if_idx 
     307 
    287308      ! local variable 
    288309      INTEGER(i4) :: il_size 
    … …  
    291312      INTEGER(i4) :: ji 
    292313      !---------------------------------------------------------------- 
    293       att_get_index=0 
     314      if_idx=0 
    294315 
    295316      il_size=SIZE(td_att(:)) 
    296317      DO ji=1,il_size 
    297318         IF( TRIM(td_att(ji)%c_name) == TRIM(cd_name) )THEN 
    298             att_get_index=ji 
     319            if_idx=ji 
    299320            EXIT 
    300321         ENDIF 
    … …  
    302323 
    303324   END FUNCTION att_get_index 
     325   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     326   FUNCTION att_get_id(td_att, cd_name) & 
     327         & RESULT (if_id) 
    304328   !------------------------------------------------------------------- 
    305329   !> @brief This function return attribute id, read from a file.<br/> 
    … …  
    316340   !> @return attribute id 
    317341   !------------------------------------------------------------------- 
    318    INTEGER(i4) FUNCTION att_get_id( td_att, cd_name ) 
    319       IMPLICIT NONE 
     342 
     343      IMPLICIT NONE 
     344 
    320345      ! Argument 
    321346      TYPE(TATT),       DIMENSION(:), INTENT(IN) :: td_att 
    322347      CHARACTER(LEN=*),               INTENT(IN) :: cd_name 
    323348 
     349      ! function 
     350      INTEGER(i4)                                :: if_id 
     351 
    324352      ! local variable 
    325353      INTEGER(i4) :: il_size 
    … …  
    328356      INTEGER(i4) :: ji 
    329357      !---------------------------------------------------------------- 
    330       att_get_id=0 
     358      if_id=0 
    331359 
    332360      il_size=SIZE(td_att(:)) 
    333361      DO ji=1,il_size 
    334362         IF( TRIM(td_att(ji)%c_name) == TRIM(cd_name) )THEN 
    335             att_get_id=td_att(ji)%i_id 
     363            if_id=td_att(ji)%i_id 
    336364            EXIT 
    337365         ENDIF 
    … …  
    339367 
    340368   END FUNCTION att_get_id 
     369   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     370   FUNCTION att__init_c(cd_name, cd_value) & 
     371         & RESULT (tf_att) 
    341372   !------------------------------------------------------------------- 
    342373   !> @brief This function initialize an attribute structure with character 
    … …  
    350381   !> @return attribute structure 
    351382   !------------------------------------------------------------------- 
    352    TYPE(TATT) FUNCTION att__init_c( cd_name, cd_value ) 
    353       IMPLICIT NONE 
     383 
     384      IMPLICIT NONE 
     385 
    354386      ! Argument 
    355387      CHARACTER(LEN=*), INTENT(IN) :: cd_name 
    356388      CHARACTER(LEN=*), INTENT(IN) :: cd_value 
     389 
     390      ! function 
     391      TYPE(TATT)                   :: tf_att 
    357392      !---------------------------------------------------------------- 
    358393  
    359394      ! clean attribute 
    360       CALL att_clean(att__init_c) 
     395      CALL att_clean(tf_att) 
    361396 
    362397      CALL logger_trace( & 
    … …  
    364399      &  " attribute value "//TRIM(ADJUSTL(cd_value)) ) 
    365400 
    366       att__init_c%c_name=TRIM(ADJUSTL(cd_name)) 
    367       att__init_c%i_type=NF90_CHAR 
    368  
    369       att__init_c%c_value=TRIM(ADJUSTL(cd_value)) 
    370       att__init_c%i_len=LEN( TRIM(ADJUSTL(cd_value)) ) 
     401      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
     402      tf_att%i_type=NF90_CHAR 
     403 
     404      tf_att%c_value=TRIM(ADJUSTL(cd_value)) 
     405      tf_att%i_len=LEN( TRIM(ADJUSTL(cd_value)) ) 
    371406 
    372407   END FUNCTION att__init_c 
     408   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     409   FUNCTION att__init_dp(cd_name, dd_value, id_type) & 
     410         & RESULT (tf_att) 
    373411   !------------------------------------------------------------------- 
    374412   !> @brief This function initialize an attribute structure with array  
    … …  
    385423   !> @return attribute structure 
    386424   !------------------------------------------------------------------- 
    387    TYPE(TATT) FUNCTION att__init_dp( cd_name, dd_value, id_type ) 
     425 
    388426      IMPLICIT NONE 
    389427 
    … …  
    393431      INTEGER(i4)                   , INTENT(IN), OPTIONAL :: id_type 
    394432 
     433      ! function 
     434      TYPE(TATT)                                 :: tf_att 
     435 
    395436      ! local value 
    396437      INTEGER(i4)       :: il_len 
    … …  
    402443 
    403444      ! clean attribute 
    404       CALL att_clean(att__init_dp) 
     445      CALL att_clean(tf_att) 
    405446 
    406447      ! array size 
    … …  
    417458      &  " attribute value "//TRIM(ADJUSTL(cl_value)) ) 
    418459 
    419       att__init_dp%c_name=TRIM(ADJUSTL(cd_name)) 
     460      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    420461 
    421462      IF( PRESENT(id_type) )THEN 
    422          att__init_dp%i_type=id_type 
     463         tf_att%i_type=id_type 
    423464      ELSE 
    424          att__init_dp%i_type=NF90_DOUBLE 
    425       ENDIF 
    426  
    427       IF( ASSOCIATED(att__init_dp%d_value) )THEN 
    428          DEALLOCATE(att__init_dp%d_value) 
    429       ENDIF 
    430       ALLOCATE(att__init_dp%d_value(il_len)) 
    431  
    432       att__init_dp%d_value(:)=dd_value(:) 
    433       att__init_dp%i_len=il_len 
     465         tf_att%i_type=NF90_DOUBLE 
     466      ENDIF 
     467 
     468      IF( ASSOCIATED(tf_att%d_value) )THEN 
     469         DEALLOCATE(tf_att%d_value) 
     470      ENDIF 
     471      ALLOCATE(tf_att%d_value(il_len)) 
     472 
     473      tf_att%d_value(:)=dd_value(:) 
     474      tf_att%i_len=il_len 
    434475 
    435476   END FUNCTION att__init_dp 
     477   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     478   FUNCTION att__init_dp_0d(cd_name, dd_value, id_type) & 
     479         & RESULT (tf_att) 
    436480   !------------------------------------------------------------------- 
    437481   !> @brief This function initialize an attribute structure with  
    … …  
    448492   !> @return attribute structure 
    449493   !------------------------------------------------------------------- 
    450    TYPE(TATT) FUNCTION att__init_dp_0d( cd_name, dd_value, id_type ) 
    451       IMPLICIT NONE 
     494 
     495      IMPLICIT NONE 
     496 
    452497      ! Argument 
    453498      CHARACTER(LEN=*), INTENT(IN) :: cd_name 
    … …  
    455500      INTEGER(i4)     , INTENT(IN), OPTIONAL :: id_type 
    456501 
     502      ! function 
     503      TYPE(TATT)                   :: tf_att 
     504 
    457505      ! local value 
    458506      CHARACTER(LEN=lc) :: cl_value 
    … …  
    460508 
    461509      ! clean attribute 
    462       CALL att_clean(att__init_dp_0d) 
     510      CALL att_clean(tf_att) 
    463511       
    464512      cl_value="(/"//TRIM(fct_str(dd_value))//"/)" 
    … …  
    468516      &  " attribute value "//TRIM(ADJUSTL(cl_value)) ) 
    469517 
    470       att__init_dp_0d%c_name=TRIM(ADJUSTL(cd_name)) 
     518      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    471519 
    472520      IF( PRESENT(id_type) )THEN 
    473          att__init_dp_0d%i_type=id_type 
     521         tf_att%i_type=id_type 
    474522      ELSE 
    475          att__init_dp_0d%i_type=NF90_DOUBLE 
    476       ENDIF 
    477  
    478       IF( ASSOCIATED(att__init_dp_0d%d_value) )THEN 
    479          DEALLOCATE(att__init_dp_0d%d_value) 
    480       ENDIF 
    481       ALLOCATE(att__init_dp_0d%d_value(1)) 
    482  
    483       att__init_dp_0d%d_value(1)=dd_value 
    484       att__init_dp_0d%i_len=1 
     523         tf_att%i_type=NF90_DOUBLE 
     524      ENDIF 
     525 
     526      IF( ASSOCIATED(tf_att%d_value) )THEN 
     527         DEALLOCATE(tf_att%d_value) 
     528      ENDIF 
     529      ALLOCATE(tf_att%d_value(1)) 
     530 
     531      tf_att%d_value(1)=dd_value 
     532      tf_att%i_len=1 
    485533 
    486534   END FUNCTION att__init_dp_0d 
     535   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     536   FUNCTION att__init_sp(cd_name, rd_value, id_type) & 
     537         & RESULT (tf_att) 
    487538   !------------------------------------------------------------------- 
    488539   !> @brief This function initialize an attribute structure with array  
    … …  
    499550   !> @return attribute structure 
    500551   !------------------------------------------------------------------- 
    501    TYPE(TATT) FUNCTION att__init_sp( cd_name, rd_value, id_type ) 
    502       IMPLICIT NONE 
     552 
     553      IMPLICIT NONE 
     554 
    503555      ! Argument 
    504556      CHARACTER(LEN=*),               INTENT(IN) :: cd_name 
    … …  
    506558      INTEGER(i4)                   , INTENT(IN), OPTIONAL :: id_type 
    507559 
     560      ! function 
     561      TYPE(TATT)                                 :: tf_att 
     562 
    508563      ! local value 
    509564      INTEGER(i4)       :: il_len 
    … …  
    515570 
    516571      ! clean attribute 
    517       CALL att_clean(att__init_sp) 
     572      CALL att_clean(tf_att) 
    518573       
    519574      ! array size 
    … …  
    524579         cl_value=TRIM(cl_value)//TRIM(fct_str(rd_value(ji)))//"," 
    525580      ENDDO 
     581      CALL logger_trace( & 
     582      &  " ATT INIT: attribute name: il_len "//fct_str(il_len)& 
     583      ) 
    526584      cl_value=TRIM(cl_value)//TRIM(fct_str(rd_value(il_len)))//"/)" 
    527585 
    … …  
    530588      &  " attribute value "//TRIM(ADJUSTL(cl_value)) )       
    531589 
    532       att__init_sp%c_name=TRIM(ADJUSTL(cd_name)) 
     590      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    533591 
    534592      IF( PRESENT(id_type) )THEN 
    535          att__init_sp%i_type=id_type 
     593         tf_att%i_type=id_type 
    536594      ELSE 
    537          att__init_sp%i_type=NF90_FLOAT 
    538       ENDIF 
    539  
    540       IF( ASSOCIATED(att__init_sp%d_value) )THEN 
    541          DEALLOCATE(att__init_sp%d_value) 
    542       ENDIF 
    543       ALLOCATE(att__init_sp%d_value(il_len)) 
    544  
    545       att__init_sp%d_value(:)=REAL(rd_value(:),dp) 
    546       att__init_sp%i_len=il_len 
     595         tf_att%i_type=NF90_FLOAT 
     596      ENDIF 
     597 
     598      IF( ASSOCIATED(tf_att%d_value) )THEN 
     599         DEALLOCATE(tf_att%d_value) 
     600      ENDIF 
     601      ALLOCATE(tf_att%d_value(il_len)) 
     602 
     603      tf_att%d_value(:)=REAL(rd_value(:),dp) 
     604      tf_att%i_len=il_len 
    547605 
    548606   END FUNCTION att__init_sp 
     607   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     608   FUNCTION att__init_sp_0d(cd_name, rd_value, id_type) & 
     609         & RESULT (tf_att) 
    549610   !------------------------------------------------------------------- 
    550611   !> @brief This function initialize an attribute structure with  
    … …  
    561622   !> @return attribute structure 
    562623   !------------------------------------------------------------------- 
    563    TYPE(TATT) FUNCTION att__init_sp_0d( cd_name, rd_value, id_type ) 
    564       IMPLICIT NONE 
     624 
     625      IMPLICIT NONE 
     626 
    565627      ! Argument 
    566628      CHARACTER(LEN=*), INTENT(IN) :: cd_name 
    … …  
    568630      INTEGER(i4)     , INTENT(IN), OPTIONAL :: id_type 
    569631 
     632      ! function 
     633      TYPE(TATT)                   :: tf_att 
     634 
    570635      ! local value 
    571636      CHARACTER(LEN=lc) :: cl_value 
    … …  
    573638 
    574639      ! clean attribute 
    575       CALL att_clean(att__init_sp_0d) 
     640      CALL att_clean(tf_att) 
    576641       
    577642      cl_value="(/"//TRIM(fct_str(rd_value))//"/)" 
    … …  
    581646      &  " attribute value "//TRIM(ADJUSTL(cl_value)) )       
    582647 
    583       att__init_sp_0d%c_name=TRIM(ADJUSTL(cd_name)) 
     648      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    584649 
    585650      IF( PRESENT(id_type) )THEN 
    586          att__init_sp_0d%i_type=id_type 
     651         tf_att%i_type=id_type 
    587652      ELSE 
    588          att__init_sp_0d%i_type=NF90_FLOAT 
    589       ENDIF 
    590  
    591       IF( ASSOCIATED(att__init_sp_0d%d_value) )THEN 
    592          DEALLOCATE(att__init_sp_0d%d_value) 
    593       ENDIF 
    594       ALLOCATE(att__init_sp_0d%d_value(1)) 
    595  
    596       att__init_sp_0d%d_value(1)=REAL(rd_value,dp) 
    597       att__init_sp_0d%i_len=1 
     653         tf_att%i_type=NF90_FLOAT 
     654      ENDIF 
     655 
     656      IF( ASSOCIATED(tf_att%d_value) )THEN 
     657         DEALLOCATE(tf_att%d_value) 
     658      ENDIF 
     659      ALLOCATE(tf_att%d_value(1)) 
     660 
     661      tf_att%d_value(1)=REAL(rd_value,dp) 
     662      tf_att%i_len=1 
    598663 
    599664   END FUNCTION att__init_sp_0d 
     665   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     666   FUNCTION att__init_i1(cd_name, bd_value, id_type) & 
     667         & RESULT (tf_att) 
    600668   !------------------------------------------------------------------- 
    601669   !> @brief This function initialize an attribute structure with array  
    … …  
    612680   !> @return attribute structure 
    613681   !------------------------------------------------------------------- 
    614    TYPE(TATT) FUNCTION att__init_i1( cd_name, bd_value, id_type ) 
    615       IMPLICIT NONE 
     682 
     683      IMPLICIT NONE 
     684 
    616685      ! Argument 
    617686      CHARACTER(LEN=*),               INTENT(IN) :: cd_name 
    … …  
    619688      INTEGER(i4)                   , INTENT(IN), OPTIONAL :: id_type 
    620689 
     690      ! function 
     691      TYPE(TATT)                                 :: tf_att 
     692 
    621693      ! local value 
    622694      INTEGER(i4)       :: il_len 
    … …  
    628700 
    629701      ! clean attribute 
    630       CALL att_clean(att__init_i1) 
     702      CALL att_clean(tf_att) 
    631703       
    632704      ! array size 
    … …  
    643715      &  " attribute value "//TRIM(ADJUSTL(cl_value)) )       
    644716 
    645       att__init_i1%c_name=TRIM(ADJUSTL(cd_name)) 
     717      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    646718 
    647719      IF( PRESENT(id_type) )THEN 
    648          att__init_i1%i_type=id_type 
     720         tf_att%i_type=id_type 
    649721      ELSE 
    650          att__init_i1%i_type=NF90_BYTE 
    651       ENDIF 
    652  
    653       IF( ASSOCIATED(att__init_i1%d_value) )THEN 
    654          DEALLOCATE(att__init_i1%d_value) 
    655       ENDIF 
    656       ALLOCATE(att__init_i1%d_value(il_len)) 
    657  
    658       att__init_i1%d_value(:)=REAL(bd_value(:),dp) 
    659       att__init_i1%i_len=il_len 
     722         tf_att%i_type=NF90_BYTE 
     723      ENDIF 
     724 
     725      IF( ASSOCIATED(tf_att%d_value) )THEN 
     726         DEALLOCATE(tf_att%d_value) 
     727      ENDIF 
     728      ALLOCATE(tf_att%d_value(il_len)) 
     729 
     730      tf_att%d_value(:)=REAL(bd_value(:),dp) 
     731      tf_att%i_len=il_len 
    660732 
    661733   END FUNCTION att__init_i1 
     734   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     735   FUNCTION att__init_i1_0d(cd_name, bd_value, id_type) & 
     736         & RESULT (tf_att) 
    662737   !------------------------------------------------------------------- 
    663738   !> @brief This function initialize an attribute structure with  
    … …  
    674749   !> @return attribute structure 
    675750   !------------------------------------------------------------------- 
    676    TYPE(TATT) FUNCTION att__init_i1_0d( cd_name, bd_value, id_type ) 
    677       IMPLICIT NONE 
     751 
     752      IMPLICIT NONE 
     753 
    678754      ! Argument 
    679755      CHARACTER(LEN=*), INTENT(IN) :: cd_name 
    … …  
    681757      INTEGER(i4)     , INTENT(IN), OPTIONAL :: id_type 
    682758 
     759      ! function 
     760      TYPE(TATT)                   :: tf_att 
     761 
    683762      !local value 
    684763      CHARACTER(LEN=lc) :: cl_value 
    … …  
    686765 
    687766      ! clean attribute 
    688       CALL att_clean(att__init_i1_0d) 
     767      CALL att_clean(tf_att) 
    689768       
    690769      cl_value="(/"//TRIM(fct_str(bd_value))//"/)" 
    … …  
    694773      &  " attibute value "//TRIM(ADJUSTL(cl_value)) )       
    695774 
    696       att__init_i1_0d%c_name=TRIM(ADJUSTL(cd_name)) 
     775      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    697776 
    698777      IF( PRESENT(id_type) )THEN 
    699          att__init_i1_0d%i_type=id_type 
     778         tf_att%i_type=id_type 
    700779      ELSE 
    701          att__init_i1_0d%i_type=NF90_BYTE 
     780         tf_att%i_type=NF90_BYTE 
    702781      ENDIF       
    703782 
    704       IF( ASSOCIATED(att__init_i1_0d%d_value) )THEN 
    705          DEALLOCATE(att__init_i1_0d%d_value) 
    706       ENDIF 
    707       ALLOCATE(att__init_i1_0d%d_value(1)) 
    708  
    709       att__init_i1_0d%d_value(1)=REAL(bd_value,dp) 
    710       att__init_i1_0d%i_len=1 
     783      IF( ASSOCIATED(tf_att%d_value) )THEN 
     784         DEALLOCATE(tf_att%d_value) 
     785      ENDIF 
     786      ALLOCATE(tf_att%d_value(1)) 
     787 
     788      tf_att%d_value(1)=REAL(bd_value,dp) 
     789      tf_att%i_len=1 
    711790 
    712791   END FUNCTION att__init_i1_0d 
     792   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     793   FUNCTION att__init_i2(cd_name, sd_value, id_type) & 
     794         & RESULT (tf_att) 
    713795   !------------------------------------------------------------------- 
    714796   !> @brief This function initialize an attribute structure with array  
    … …  
    725807   !> @return attribute structure 
    726808   !------------------------------------------------------------------- 
    727    TYPE(TATT) FUNCTION att__init_i2( cd_name, sd_value, id_type ) 
    728       IMPLICIT NONE 
     809 
     810      IMPLICIT NONE 
     811 
    729812      ! Argument 
    730813      CHARACTER(LEN=*),               INTENT(IN) :: cd_name 
    … …  
    732815      INTEGER(i4)                   , INTENT(IN), OPTIONAL :: id_type 
    733816 
     817      ! function 
     818      TYPE(TATT)                                 :: tf_att 
     819 
    734820      ! local value 
    735821      INTEGER(i4)       :: il_len 
    … …  
    741827 
    742828      ! clean attribute 
    743       CALL att_clean(att__init_i2) 
     829      CALL att_clean(tf_att) 
    744830       
    745831      ! array size 
    … …  
    756842      &  " attribute value "//TRIM(ADJUSTL(cl_value)) )       
    757843 
    758       att__init_i2%c_name=TRIM(ADJUSTL(cd_name)) 
     844      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    759845 
    760846      IF( PRESENT(id_type) )THEN 
    761          att__init_i2%i_type=id_type 
     847         tf_att%i_type=id_type 
    762848      ELSE 
    763          att__init_i2%i_type=NF90_SHORT 
    764       ENDIF 
    765  
    766       IF( ASSOCIATED(att__init_i2%d_value) )THEN 
    767          DEALLOCATE(att__init_i2%d_value) 
    768       ENDIF 
    769       ALLOCATE(att__init_i2%d_value(il_len)) 
    770  
    771       att__init_i2%d_value(:)=REAL(sd_value(:),dp) 
    772       att__init_i2%i_len=il_len 
     849         tf_att%i_type=NF90_SHORT 
     850      ENDIF 
     851 
     852      IF( ASSOCIATED(tf_att%d_value) )THEN 
     853         DEALLOCATE(tf_att%d_value) 
     854      ENDIF 
     855      ALLOCATE(tf_att%d_value(il_len)) 
     856 
     857      tf_att%d_value(:)=REAL(sd_value(:),dp) 
     858      tf_att%i_len=il_len 
    773859 
    774860   END FUNCTION att__init_i2 
     861   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     862   FUNCTION att__init_i2_0d(cd_name, sd_value, id_type) & 
     863         & RESULT (tf_att) 
    775864   !------------------------------------------------------------------- 
    776865   !> @brief This function initialize an attribute structure with  
    … …  
    787876   !> @return attribute structure 
    788877   !------------------------------------------------------------------- 
    789    TYPE(TATT) FUNCTION att__init_i2_0d( cd_name, sd_value, id_type ) 
    790       IMPLICIT NONE 
     878 
     879      IMPLICIT NONE 
     880 
    791881      ! Argument 
    792882      CHARACTER(LEN=*), INTENT(IN) :: cd_name 
    … …  
    794884      INTEGER(i4)     , INTENT(IN), OPTIONAL :: id_type 
    795885 
     886      ! function 
     887      TYPE(TATT)                   :: tf_att 
     888 
    796889      !local value 
    797890      CHARACTER(LEN=lc) :: cl_value 
    … …  
    799892 
    800893      ! clean attribute 
    801       CALL att_clean(att__init_i2_0d) 
     894      CALL att_clean(tf_att) 
    802895       
    803896      cl_value="(/"//TRIM(fct_str(sd_value))//"/)" 
    … …  
    807900      &  " attibute value "//TRIM(ADJUSTL(cl_value)) )       
    808901 
    809       att__init_i2_0d%c_name=TRIM(ADJUSTL(cd_name)) 
     902      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    810903 
    811904      IF( PRESENT(id_type) )THEN 
    812          att__init_i2_0d%i_type=id_type 
     905         tf_att%i_type=id_type 
    813906      ELSE 
    814          att__init_i2_0d%i_type=NF90_SHORT 
    815       ENDIF 
    816  
    817       IF( ASSOCIATED(att__init_i2_0d%d_value) )THEN 
    818          DEALLOCATE(att__init_i2_0d%d_value) 
    819       ENDIF 
    820       ALLOCATE(att__init_i2_0d%d_value(1)) 
    821  
    822       att__init_i2_0d%d_value(1)=REAL(sd_value,dp) 
    823       att__init_i2_0d%i_len=1 
     907         tf_att%i_type=NF90_SHORT 
     908      ENDIF 
     909 
     910      IF( ASSOCIATED(tf_att%d_value) )THEN 
     911         DEALLOCATE(tf_att%d_value) 
     912      ENDIF 
     913      ALLOCATE(tf_att%d_value(1)) 
     914 
     915      tf_att%d_value(1)=REAL(sd_value,dp) 
     916      tf_att%i_len=1 
    824917 
    825918   END FUNCTION att__init_i2_0d 
     919   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     920   FUNCTION att__init_i4(cd_name, id_value, id_type) & 
     921         & RESULT(tf_att) 
    826922   !------------------------------------------------------------------- 
    827923   !> @brief This function initialize an attribute structure with array  
    … …  
    838934   !> @return attribute structure 
    839935   !------------------------------------------------------------------- 
    840    TYPE(TATT) FUNCTION att__init_i4( cd_name, id_value, id_type ) 
    841       IMPLICIT NONE 
     936 
     937      IMPLICIT NONE 
     938 
    842939      ! Argument 
    843940      CHARACTER(LEN=*),               INTENT(IN) :: cd_name 
    … …  
    845942      INTEGER(i4)                   , INTENT(IN), OPTIONAL :: id_type 
    846943 
     944      ! function 
     945      TYPE(TATT)                                 :: tf_att 
     946 
    847947      ! local value 
    848948      INTEGER(i4)       :: il_len 
    … …  
    854954 
    855955      ! clean attribute 
    856       CALL att_clean(att__init_i4) 
     956      CALL att_clean(tf_att) 
    857957       
    858958      ! array size 
    … …  
    869969      &  " attribute value "//TRIM(ADJUSTL(cl_value)) )       
    870970 
    871       att__init_i4%c_name=TRIM(ADJUSTL(cd_name)) 
     971      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    872972 
    873973      IF( PRESENT(id_type) )THEN 
    874          att__init_i4%i_type=id_type 
     974         tf_att%i_type=id_type 
    875975      ELSE 
    876          att__init_i4%i_type=NF90_INT 
    877       ENDIF 
    878  
    879       IF( ASSOCIATED(att__init_i4%d_value) )THEN 
    880          DEALLOCATE(att__init_i4%d_value) 
    881       ENDIF 
    882       ALLOCATE(att__init_i4%d_value(il_len)) 
    883  
    884       att__init_i4%d_value(:)=REAL(id_value(:),dp) 
    885       att__init_i4%i_len=il_len 
     976         tf_att%i_type=NF90_INT 
     977      ENDIF 
     978 
     979      IF( ASSOCIATED(tf_att%d_value) )THEN 
     980         DEALLOCATE(tf_att%d_value) 
     981      ENDIF 
     982      ALLOCATE(tf_att%d_value(il_len)) 
     983 
     984      tf_att%d_value(:)=REAL(id_value(:),dp) 
     985      tf_att%i_len=il_len 
    886986 
    887987   END FUNCTION att__init_i4 
     988   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     989   FUNCTION att__init_i4_0d(cd_name, id_value, id_type) & 
     990         & RESULT (tf_att) 
    888991   !------------------------------------------------------------------- 
    889992   !> @brief This function initialize an attribute structure with  
    … …  
    9001003   !> @return attribute structure 
    9011004   !------------------------------------------------------------------- 
    902    TYPE(TATT) FUNCTION att__init_i4_0d( cd_name, id_value, id_type ) 
    903       IMPLICIT NONE 
     1005 
     1006      IMPLICIT NONE 
     1007 
    9041008      ! Argument 
    9051009      CHARACTER(LEN=*), INTENT(IN) :: cd_name 
    … …  
    9071011      INTEGER(i4)     , INTENT(IN), OPTIONAL :: id_type 
    9081012 
     1013      ! function 
     1014      TYPE(TATT)                   :: tf_att 
     1015 
    9091016      !local value 
    9101017      CHARACTER(LEN=lc) :: cl_value 
    … …  
    9121019 
    9131020      ! clean attribute 
    914       CALL att_clean(att__init_i4_0d) 
     1021      CALL att_clean(tf_att) 
    9151022       
    9161023      cl_value="(/"//TRIM(fct_str(id_value))//"/)" 
    … …  
    9201027      &  " attibute value "//TRIM(ADJUSTL(cl_value)) )       
    9211028 
    922       att__init_i4_0d%c_name=TRIM(ADJUSTL(cd_name)) 
     1029      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    9231030 
    9241031      IF( PRESENT(id_type) )THEN 
    925          att__init_i4_0d%i_type=id_type 
     1032         tf_att%i_type=id_type 
    9261033      ELSE 
    927          att__init_i4_0d%i_type=NF90_INT 
    928       ENDIF 
    929  
    930       IF( ASSOCIATED(att__init_i4_0d%d_value) )THEN 
    931          DEALLOCATE(att__init_i4_0d%d_value) 
    932       ENDIF 
    933       ALLOCATE(att__init_i4_0d%d_value(1)) 
    934  
    935       att__init_i4_0d%d_value(1)=REAL(id_value,dp) 
    936       att__init_i4_0d%i_len=1 
     1034         tf_att%i_type=NF90_INT 
     1035      ENDIF 
     1036 
     1037      IF( ASSOCIATED(tf_att%d_value) )THEN 
     1038         DEALLOCATE(tf_att%d_value) 
     1039      ENDIF 
     1040      ALLOCATE(tf_att%d_value(1)) 
     1041 
     1042      tf_att%d_value(1)=REAL(id_value,dp) 
     1043      tf_att%i_len=1 
    9371044 
    9381045   END FUNCTION att__init_i4_0d 
     1046   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1047   FUNCTION att__init_i8(cd_name, kd_value, id_type) & 
     1048         & RESULT (tf_att) 
    9391049   !------------------------------------------------------------------- 
    9401050   !> @brief This function initialize an attribute structure with array  
    … …  
    9511061   !> @return attribute structure 
    9521062   !------------------------------------------------------------------- 
    953    TYPE(TATT) FUNCTION att__init_i8( cd_name, kd_value, id_type ) 
    954       IMPLICIT NONE 
     1063 
     1064      IMPLICIT NONE 
     1065 
    9551066      ! Argument 
    9561067      CHARACTER(LEN=*),               INTENT(IN) :: cd_name 
    … …  
    9581069      INTEGER(i4)                   , INTENT(IN), OPTIONAL :: id_type 
    9591070 
     1071      ! function 
     1072      TYPE(TATT)                                 :: tf_att 
     1073 
    9601074      ! local value 
    9611075      INTEGER(i4)       :: il_len 
    … …  
    9671081 
    9681082      ! clean attribute 
    969       CALL att_clean(att__init_i8) 
     1083      CALL att_clean(tf_att) 
    9701084       
    9711085      ! array size 
    … …  
    9821096      &  " attibute value "//TRIM(ADJUSTL(cl_value)) )       
    9831097 
    984       att__init_i8%c_name=TRIM(ADJUSTL(cd_name)) 
     1098      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    9851099 
    9861100      IF( PRESENT(id_type) )THEN 
    987          att__init_i8%i_type=id_type 
     1101         tf_att%i_type=id_type 
    9881102      ELSE 
    989          att__init_i8%i_type=NF90_INT 
    990       ENDIF 
    991  
    992       IF( ASSOCIATED(att__init_i8%d_value) )THEN 
    993          DEALLOCATE(att__init_i8%d_value) 
    994       ENDIF 
    995       ALLOCATE(att__init_i8%d_value(il_len)) 
    996  
    997       att__init_i8%d_value(:)=REAL(kd_value(:),dp) 
    998       att__init_i8%i_len=il_len 
     1103         tf_att%i_type=NF90_INT 
     1104      ENDIF 
     1105 
     1106      IF( ASSOCIATED(tf_att%d_value) )THEN 
     1107         DEALLOCATE(tf_att%d_value) 
     1108      ENDIF 
     1109      ALLOCATE(tf_att%d_value(il_len)) 
     1110 
     1111      tf_att%d_value(:)=REAL(kd_value(:),dp) 
     1112      tf_att%i_len=il_len 
    9991113 
    10001114   END FUNCTION att__init_i8 
     1115   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1116   FUNCTION att__init_i8_0d(cd_name, kd_value, id_type) & 
     1117         & RESULT (tf_att) 
    10011118   !------------------------------------------------------------------- 
    10021119   !> @brief This function initialize an attribute structure with  
    … …  
    10131130   !> @return attribute structure 
    10141131   !------------------------------------------------------------------- 
    1015    TYPE(TATT) FUNCTION att__init_i8_0d( cd_name, kd_value, id_type ) 
    1016       IMPLICIT NONE 
     1132 
     1133      IMPLICIT NONE 
     1134 
    10171135      ! Argument 
    10181136      CHARACTER(LEN=*), INTENT(IN) :: cd_name 
    … …  
    10201138      INTEGER(i4)     , INTENT(IN), OPTIONAL :: id_type 
    10211139 
     1140      ! function 
     1141      TYPE(TATT)                   :: tf_att 
     1142 
    10221143      ! local value 
    10231144      CHARACTER(LEN=lc) :: cl_value 
    … …  
    10251146 
    10261147      ! clean attribute 
    1027       CALL att_clean(att__init_i8_0d) 
     1148      CALL att_clean(tf_att) 
    10281149       
    10291150      cl_value="(/"//TRIM(fct_str(kd_value))//"/)" 
    … …  
    10331154      &  " attibute value "//TRIM(ADJUSTL(cl_value)) )       
    10341155 
    1035       att__init_i8_0d%c_name=TRIM(ADJUSTL(cd_name)) 
     1156      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
    10361157 
    10371158      IF( PRESENT(id_type) )THEN 
    1038          att__init_i8_0d%i_type=id_type 
     1159         tf_att%i_type=id_type 
    10391160      ELSE 
    1040          att__init_i8_0d%i_type=NF90_INT 
    1041       ENDIF 
    1042  
    1043       IF( ASSOCIATED(att__init_i8_0d%d_value) )THEN 
    1044          DEALLOCATE(att__init_i8_0d%d_value) 
    1045       ENDIF 
    1046       ALLOCATE(att__init_i8_0d%d_value(1)) 
    1047  
    1048       att__init_i8_0d%d_value(1)=REAL(kd_value,dp) 
    1049       att__init_i8_0d%i_len=1 
     1161         tf_att%i_type=NF90_INT 
     1162      ENDIF 
     1163 
     1164      IF( ASSOCIATED(tf_att%d_value) )THEN 
     1165         DEALLOCATE(tf_att%d_value) 
     1166      ENDIF 
     1167      ALLOCATE(tf_att%d_value(1)) 
     1168 
     1169      tf_att%d_value(1)=REAL(kd_value,dp) 
     1170      tf_att%i_len=1 
    10501171 
    10511172   END FUNCTION att__init_i8_0d 
     1173   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1174   SUBROUTINE att__print_arr(td_att) 
    10521175   !------------------------------------------------------------------- 
    10531176   !> @brief This subroutine print informations of an array of attribute.  
    … …  
    10581181   !> @param[in] td_att array of attribute structure 
    10591182   !------------------------------------------------------------------- 
    1060    SUBROUTINE att__print_arr(td_att) 
     1183 
    10611184      IMPLICIT NONE 
    10621185 
    … …  
    10731196 
    10741197   END SUBROUTINE att__print_arr 
     1198   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1199   SUBROUTINE att__print_unit(td_att) 
    10751200   !------------------------------------------------------------------- 
    10761201   !> @brief This subroutine print attribute information. 
    … …  
    10831208   !> @param[in] td_att attribute structure 
    10841209   !------------------------------------------------------------------- 
    1085    SUBROUTINE att__print_unit(td_att) 
     1210 
    10861211      IMPLICIT NONE 
    10871212 
    … …  
    12051330 
    12061331   END SUBROUTINE att__print_unit 
     1332   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1333   SUBROUTINE att__clean_unit(td_att) 
    12071334   !------------------------------------------------------------------- 
    12081335   !> @brief  
    … …  
    12111338   !> @author J.Paul 
    12121339   !> @date November, 2013 - Initial Version 
    1213    ! 
     1340   !> @date January, 2019  
     1341   !> - nullify array inside attribute structure 
     1342   !> 
    12141343   !> @param[inout] td_att attribute strcuture 
    12151344   !------------------------------------------------------------------- 
    1216    SUBROUTINE att__clean_unit( td_att ) 
    1217       IMPLICIT NONE 
     1345 
     1346      IMPLICIT NONE 
     1347 
    12181348      ! Argument 
    12191349      TYPE(TATT),  INTENT(INOUT) :: td_att 
    … …  
    12291359         ! clean value 
    12301360         DEALLOCATE(td_att%d_value) 
     1361         NULLIFY(td_att%d_value) 
    12311362      ENDIF 
    12321363 
    … …  
    12351366 
    12361367   END SUBROUTINE att__clean_unit 
     1368   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1369   SUBROUTINE att__clean_arr(td_att) 
    12371370   !------------------------------------------------------------------- 
    12381371   !> @brief  
    … …  
    12441377   !> @param[inout] td_att attribute strcuture 
    12451378   !------------------------------------------------------------------- 
    1246    SUBROUTINE att__clean_arr( td_att ) 
    1247       IMPLICIT NONE 
     1379 
     1380      IMPLICIT NONE 
     1381 
    12481382      ! Argument 
    12491383      TYPE(TATT), DIMENSION(:), INTENT(INOUT) :: td_att 
    … …  
    12591393 
    12601394   END SUBROUTINE att__clean_arr 
     1395   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1396   SUBROUTINE att_get_dummy(cd_dummy) 
    12611397   !------------------------------------------------------------------- 
    12621398   !> @brief This subroutine fill dummy attribute array 
    … …  
    12661402   !> @date Marsh, 2016 
    12671403   !> - close file (bugfix) 
    1268    ! 
     1404   !> @date May, 2019 
     1405   !> - read number of dummy element  
     1406   !> 
    12691407   !> @param[in] cd_dummy dummy configuration file 
    12701408   !------------------------------------------------------------------- 
    1271    SUBROUTINE att_get_dummy( cd_dummy ) 
    1272       IMPLICIT NONE 
     1409 
     1410      IMPLICIT NONE 
     1411 
    12731412      ! Argument 
    12741413      CHARACTER(LEN=*), INTENT(IN) :: cd_dummy 
    … …  
    12801419      LOGICAL       :: ll_exist 
    12811420 
    1282       ! loop indices 
    12831421      ! namelist 
     1422      INTEGER(i4)                                :: in_ndumvar 
     1423      INTEGER(i4)                                :: in_ndumdim 
     1424      INTEGER(i4)                                :: in_ndumatt 
    12841425      CHARACTER(LEN=lc), DIMENSION(ip_maxdumcfg) :: cn_dumvar 
    12851426      CHARACTER(LEN=lc), DIMENSION(ip_maxdumcfg) :: cn_dumdim 
    12861427      CHARACTER(LEN=lc), DIMENSION(ip_maxdumcfg) :: cn_dumatt 
    1287  
    12881428      !---------------------------------------------------------------- 
    12891429      NAMELIST /namdum/ &   !< dummy namelist 
     1430      &  in_ndumvar,&       !< number of dummy elt in variable array 
     1431      &  in_ndumdim,&       !< number of dummy elt in dimension array 
     1432      &  in_ndumatt,&       !< number of dummy elt in attribute array 
    12901433      &  cn_dumvar, &       !< variable  name 
    12911434      &  cn_dumdim, &       !< dimension name 
    … …  
    13141457    
    13151458         READ( il_fileid, NML = namdum ) 
    1316          cm_dumatt(:)=cn_dumatt(:) 
     1459         im_ndumatt  = in_ndumatt 
     1460         cm_dumatt(:)= cn_dumatt(:) 
    13171461 
    13181462         CLOSE( il_fileid ) 
     1463 
     1464         IF( im_ndumatt > ip_maxdumcfg )THEN 
     1465            CALL logger_fatal("ATT GET dUMMY : too much dummy attributes & 
     1466            &     ( >"//fct_str(ip_maxdumcfg)//" ). & 
     1467            &     set ip_maxdumcfg to higher value.") 
     1468         ENDIF 
    13191469 
    13201470      ENDIF 
    13211471    
    13221472   END SUBROUTINE att_get_dummy 
     1473   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1474   FUNCTION att_is_dummy(td_att) & 
     1475         & RESULT (lf_dummy) 
    13231476   !------------------------------------------------------------------- 
    13241477   !> @brief This function check if attribute is defined as dummy attribute 
    … …  
    13271480   !> @author J.Paul 
    13281481   !> @date September, 2015 - Initial Version 
    1329    ! 
     1482   !> @date, May, 2019 
     1483   !> - use number of dummy elt in do-loop 
     1484   !> 
    13301485   !> @param[in] td_att attribute structure 
    13311486   !> @return true if attribute is dummy attribute 
    13321487   !------------------------------------------------------------------- 
    1333    FUNCTION att_is_dummy(td_att) 
     1488 
    13341489      IMPLICIT NONE 
    13351490 
    … …  
    13381493       
    13391494      ! function 
    1340       LOGICAL :: att_is_dummy 
     1495      LOGICAL                :: lf_dummy 
    13411496       
    13421497      ! loop indices 
    … …  
    13441499      !---------------------------------------------------------------- 
    13451500 
    1346       att_is_dummy=.FALSE. 
    1347       DO ji=1,ip_maxdumcfg 
     1501      CALL logger_trace("ATT IS DUMMY : check if attribute is useless") 
     1502 
     1503      lf_dummy=.FALSE. 
     1504      DO ji=1,im_ndumatt 
    13481505         IF( fct_lower(td_att%c_name) == fct_lower(cm_dumatt(ji)) )THEN 
    1349             att_is_dummy=.TRUE. 
     1506            lf_dummy=.TRUE. 
    13501507            EXIT 
    13511508         ENDIF 
    13521509      ENDDO 
    13531510 
     1511      CALL logger_trace("ATT IS DUMMY : check ok") 
     1512 
    13541513   END FUNCTION att_is_dummy 
     1514   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    13551515END MODULE att 
    13561516 
Note: See TracChangeset for help on using the changeset viewer.