Changeset 13369


Ignore:
Timestamp:
2020-07-31T10:50:52+02:00 (2 weeks ago)
Author:
jpaul
Message:

update: cf changelog inside documentation

Location:
utils/tools/SIREN
Files:
48 edited

Legend:

Unmodified
Added
Removed
  • utils/tools/SIREN/Doxyfile

    • Property dummy set to 1
  • utils/tools/SIREN/src/addline_deg.f90

    r12080 r13369  
    33!---------------------------------------------------------------------- 
    44!> @file 
    5 !> @brief  
     5!> @brief 
    66!> This program add line to all variables of the input file. 
    77!> 
     
    2525!> 
    2626!>    here after, each sub-namelist parameters is detailed. 
    27 !>    @note  
     27!>    @note 
    2828!>       default values are specified between brackets 
    2929!> 
     
    4444!>          - none 
    4545!> 
    46 !>    - **in_maxerror** [@a 5]<br/>  
     46!>    - **in_maxerror** [@a 5]<br/> 
    4747!>       maximum number of error allowed 
    4848!> 
     
    5252!>    - **cn_varcfg** [@a ./cfg/variable.cfg]<br/> 
    5353!>       path to the variable configuration file.<br/> 
    54 !>       the variable configuration file defines standard name,  
    55 !>       default interpolation method, axis,...  
    56 !>       to be used for some known variables.<br/>  
    57 !> 
    58 !>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/>  
    59 !>       path to the dimension configuration file.<br/>  
    60 !>       the dimension configuration file defines dimensions allowed.<br/>  
    61 !> 
    62 !>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/>  
     54!>       the variable configuration file defines standard name, 
     55!>       default interpolation method, axis,... 
     56!>       to be used for some known variables.<br/> 
     57!> 
     58!>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/> 
     59!>       path to the dimension configuration file.<br/> 
     60!>       the dimension configuration file defines dimensions allowed.<br/> 
     61!> 
     62!>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/> 
    6363!>       path to the useless (dummy) configuration file.<br/> 
    64 !>       the dummy configuration file defines useless  
     64!>       the dummy configuration file defines useless 
    6565!>       dimension or variable. these dimension(s) or variable(s) will not be 
    6666!>       processed.<br/> 
    6767!> 
    68 !> @subsection subsrc namsrc  
     68!> @subsection subsrc namsrc 
    6969!>    the source/coarse grid sub-namelist parameters are : 
    7070!> 
    71 !>    - **cn_coord0** [@a ]<br/>  
     71!>    - **cn_coord0** [@a ]<br/> 
    7272!>       path to the coordinate file 
    7373!> 
    74 !>    - **in_perio0** [@a ]<br/>  
    75 !>       NEMO periodicity index<br/>  
     74!>    - **in_perio0** [@a ]<br/> 
     75!>       NEMO periodicity index<br/> 
    7676!>       the NEMO periodicity could be choose between 0 to 6: 
    7777!>       <dl> 
     
    9595!>       </dl> 
    9696!>       @sa For more information see @ref md_src_docsrc_6_perio 
    97 !>       and Model Boundary Condition paragraph in the  
     97!>       and Model Boundary Condition paragraph in the 
    9898!>       [NEMO documentation](https://forge.ipsl.jussieu.fr/nemo/chrome/site/doc/NEMO/manual/pdf/NEMO_manual.pdf) 
    9999!> 
    100 !> @subsection subvar namvar  
     100!> @subsection subvar namvar 
    101101!>    the variable sub-namelist parameters are : 
    102102!> 
    103 !>    - **cn_varfile** [@a ]<br/>  
    104 !>       list of variable, and associated file  
     103!>    - **cn_varfile** [@a ]<br/> 
     104!>       list of variable, and associated file 
    105105!> 
    106106!>       *cn_varfile* is the path and filename of the file where find 
    107107!>       variable. 
    108 !>       @note  
     108!>       @note 
    109109!>          *cn_varfile* could be a matrix of value, if you want to handwrite 
    110110!>          variable value.<br/> 
    111111!>          the variable array of value is split into equal subdomain.<br/> 
    112 !>          each subdomain is filled with the corresponding value  
    113 !>          of the matrix.<br/>           
     112!>          each subdomain is filled with the corresponding value 
     113!>          of the matrix.<br/> 
    114114!>          separators used to defined matrix are: 
    115115!>             - ',' for line 
     
    120120!>                                      1 & 4 & 5 \end{array} \right) @f$ 
    121121!> 
    122 !>       Examples:  
     122!>       Examples: 
    123123!>          - 'Bathymetry:gridT.nc' 
    124124!> 
    125 !>       @note  
     125!>       @note 
    126126!>          Optionnaly, NEMO periodicity could be added following the filename. 
    127127!>          the periodicity must be separated by ';' 
     
    130130!>          - 'Bathymetry:gridT.nc ; perio=4'<br/> 
    131131!> 
    132 !>    - **cn_varinfo** [@a ]<br/>  
     132!>    - **cn_varinfo** [@a ]<br/> 
    133133!>       list of variable and extra information about request(s) to be used<br/> 
    134134!> 
    135135!>       each elements of *cn_varinfo* is a string character (separated by ',').<br/> 
    136 !>       it is composed of the variable name follow by ':',  
    137 !>       then request(s) to be used on this variable.<br/>  
     136!>       it is composed of the variable name follow by ':', 
     137!>       then request(s) to be used on this variable.<br/> 
    138138!>       request could be: 
    139139!>          - int = interpolation method 
     
    150150!>       informations about available method could be find in @ref interp, 
    151151!>       @ref extrap and @ref filter modules.<br/> 
    152 !>       Example:  
     152!>       Example: 
    153153!>          - 'Bathymetry: flt=2*hamming(2,3); min=0' 
    154154!> 
    155 !>       @note  
    156 !>          If you do not specify a method which is required,  
     155!>       @note 
     156!>          If you do not specify a method which is required, 
    157157!>          default one is apply. 
    158158!> 
    159 !> @subsection subout namout  
     159!> @subsection subout namout 
    160160!>    the output sub-namelist parameter is : 
    161161!> 
     
    163163!>       output filename 
    164164!>    - @b ln_extrap [@a .FALSE.]<br/> 
    165 !>       extrapolate extra line  
     165!>       extrapolate extra line 
    166166!>    - @b ln_copy [@a .FALSE.]<br/> 
    167167!>       copy extra line from above 
     
    220220 
    221221   TYPE(TATT)                                         :: tl_att 
    222     
     222 
    223223   TYPE(TVAR)                                         :: tl_lon 
    224224   TYPE(TVAR)                                         :: tl_lat 
     
    228228   TYPE(TVAR)                                         :: tl_tmp 
    229229   TYPE(TVAR)       , DIMENSION(:), ALLOCATABLE       :: tl_var 
    230     
     230 
    231231   TYPE(TDIM)       , DIMENSION(ip_maxdim)            :: tl_dim 
    232232 
     
    241241   ! namelist variable 
    242242   ! namlog 
    243    CHARACTER(LEN=lc)                       :: cn_logfile = 'addline.log'  
    244    CHARACTER(LEN=lc)                       :: cn_verbosity = 'warning'  
     243   CHARACTER(LEN=lc)                       :: cn_logfile = 'addline.log' 
     244   CHARACTER(LEN=lc)                       :: cn_verbosity = 'warning' 
    245245   INTEGER(i4)                             :: in_maxerror = 5 
    246246 
    247247   ! namcfg 
    248    CHARACTER(LEN=lc)                       :: cn_varcfg = 'variable.cfg'  
    249    CHARACTER(LEN=lc)                       :: cn_dimcfg = 'dimension.cfg'  
    250    CHARACTER(LEN=lc)                       :: cn_dumcfg = 'dummy.cfg'  
     248   CHARACTER(LEN=lc)                       :: cn_varcfg = 'variable.cfg' 
     249   CHARACTER(LEN=lc)                       :: cn_dimcfg = 'dimension.cfg' 
     250   CHARACTER(LEN=lc)                       :: cn_dumcfg = 'dummy.cfg' 
    251251 
    252252   ! namsrc 
    253    CHARACTER(LEN=lc)                       :: cn_coord0 = ''  
     253   CHARACTER(LEN=lc)                       :: cn_coord0 = '' 
    254254   INTEGER(i4)                             :: in_perio0 = -1 
    255255 
     
    259259 
    260260   ! namout 
    261    CHARACTER(LEN=lc)                       :: cn_fileout = 'addline_deg.nc'  
     261   CHARACTER(LEN=lc)                       :: cn_fileout = 'addline_deg.nc' 
    262262   LOGICAL                                 :: ln_extrap  = .FALSE. 
    263263   LOGICAL                                 :: ln_copy    = .FALSE. 
     
    281281   &  cn_coord0,  &      !< coordinate file 
    282282   &  in_perio0          !< periodicity index 
    283     
     283 
    284284   NAMELIST /namvar/ &   !< variable namelist 
    285285   &  cn_varinfo, &      !< list of variable and interpolation method to be used. (ex: 'votemper:linear','vosaline:cubic' ) 
     
    305305      CALL GET_COMMAND_ARGUMENT(1,cl_namelist) !f03 intrinsec 
    306306   ENDIF 
    307   
     307 
    308308   ! read namelist 
    309309   INQUIRE(FILE=TRIM(cl_namelist), EXIST=ll_exist) 
    310310   IF( ll_exist )THEN 
    311   
     311 
    312312      il_fileid=fct_getunit() 
    313313 
     
    349349      ! match variable with file 
    350350      tl_multi=multi_init(cn_varfile) 
    351        
     351 
    352352      READ( il_fileid, NML = namout ) 
    353353 
     
    373373   ELSE 
    374374      CALL logger_fatal("ADD LINE: no coarse grid coordinate found. "//& 
    375       &     "check namelist")       
     375      &     "check namelist") 
    376376   ENDIF 
    377377 
     
    393393      jk=0 
    394394      DO ji=1,tl_multi%i_nmpp 
    395        
     395 
    396396         IF( .NOT. ASSOCIATED(tl_multi%t_mpp(ji)%t_proc(1)%t_var) )THEN 
    397397 
     
    445445            CALL iom_mpp_close(tl_mpp) 
    446446 
    447             !- add line to input file variable  
     447            !- add line to input file variable 
    448448            DO jj=1,tl_multi%t_mpp(ji)%t_proc(1)%i_nvar 
    449449               jk=jk+1 
    450450               tl_tmp=var_copy(tl_multi%t_mpp(ji)%t_proc(1)%t_var(jj)) 
    451451               WRITE(*,'(2x,a)') "work on variable "//TRIM(tl_tmp%c_name) 
    452              
     452 
    453453               tl_var(jk)=add_line( tl_tmp, tl_mpp, & 
    454454               &                    tl_coord0 ) 
     
    500500   DO ji=1,ip_maxdim 
    501501 
    502       IF( tl_dim(ji)%l_use )THEN 
     502      IF( tl_dim(ji)%l_use .AND. .NOT. tl_mppout%t_dim(ji)%l_use )THEN 
    503503         CALL mpp_move_dim(tl_mppout, tl_dim(ji)) 
    504504         SELECT CASE(TRIM(tl_dim(ji)%c_sname)) 
     
    507507               CALL file_add_dim(tl_mppout%t_proc(jj), tl_dim(ji)) 
    508508            ENDDO 
    509          END SELECT  
     509         END SELECT 
    510510      ENDIF 
    511511 
     
    589589      CALL mpp_add_att(tl_mppout,tl_att) 
    590590   ENDIF 
    591     
     591 
    592592   ! print 
    593593   CALL mpp_print(tl_mppout) 
     
    620620   !> @brief 
    621621   !> This function add line to variable and return variable structure 
    622    !>  
     622   !> 
    623623   !> @author J.Paul 
    624624   !> @date October, 2015 - Initial Version 
    625625   !> 
    626    !> @param[in] td_var    variable structure  
     626   !> @param[in] td_var    variable structure 
    627627   !> @param[in] td_mpp    mpp file structure 
    628628   !> @param[in] td_coord  coordinate file structure 
    629629   !> @return variable structure 
    630630   !------------------------------------------------------------------- 
    631        
     631 
    632632      IMPLICIT NONE 
    633633 
    634634      ! Argument 
    635       TYPE(TVAR), INTENT(IN) :: td_var   
     635      TYPE(TVAR), INTENT(IN) :: td_var 
    636636      TYPE(TMPP), INTENT(IN) :: td_mpp 
    637637      TYPE(TMPP), INTENT(IN) :: td_coord 
     
    680680         ! add attribute to variable 
    681681         tl_att=att_init('src_file',TRIM(fct_basename(tl_mpp%c_name))) 
    682          CALL var_move_att(tf_var, tl_att)          
     682         CALL var_move_att(tf_var, tl_att) 
    683683 
    684684         tl_att=att_init('add_i_line',(/il_ghost(jp_I,1), il_ghost(jp_I,2)/)) 
     
    695695   END FUNCTION add_line 
    696696   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    697 END PROGRAM  
     697END PROGRAM 
  • utils/tools/SIREN/src/attribute.f90

    r12080 r13369  
    44! 
    55! DESCRIPTION: 
    6 !> @brief  
     6!> @brief 
    77!> This module manage attribute of variable or file. 
    88!> 
     
    2828!>    to print attribute information of one or array of attribute structure:<br/> 
    2929!> @code 
    30 !>    CALL att_print(td_att)  
     30!>    CALL att_print(td_att) 
    3131!> @endcode 
    3232!> 
    3333!>    to clean attribute structure:<br/> 
    3434!> @code 
    35 !>    CALL att_clean(td_att)  
     35!>    CALL att_clean(td_att) 
    3636!> @endcode 
    3737!> 
    3838!>    to copy attribute structure in another one (using different memory cell):<br/> 
    3939!> @code 
    40 !>    tl_att2=att_copy(tl_att1)  
     40!>    tl_att2=att_copy(tl_att1) 
    4141!> @endcode 
    4242!>    @note as we use pointer for the value array of the attribute structure, 
    43 !>    the use of the assignment operator (=) to copy attribute structure  
    44 !>    create a pointer on the same array.  
     43!>    the use of the assignment operator (=) to copy attribute structure 
     44!>    create a pointer on the same array. 
    4545!>    This is not the case with this copy function. 
    4646!> 
     
    5151!>    - td_att array of attribute structure 
    5252!>    - cd_name attribute name 
    53 !>  
     53!> 
    5454!>    to get attribute id, read from a file:<br/> 
    5555!>@code 
     
    6161!>    to get attribute name 
    6262!>    - tl_att\%c_name 
    63 !>  
     63!> 
    6464!>    to get character length or the number of value store in attribute 
    6565!>    - tl_att\%i_len 
     
    6868!>    - tl_att\%c_value    (for character attribute) 
    6969!>    - tl_att\%d_value(i) (otherwise) 
    70 !>     
    71 !>    to get the type number (based on NETCDF type constants) of the  
     70!> 
     71!>    to get the type number (based on NETCDF type constants) of the 
    7272!>    attribute:<br/> 
    7373!>    - tl_att\%i_type 
     
    7979!> 
    8080!> @date November, 2013 - Initial Version 
    81 !> @date November, 2014  
     81!> @date November, 2014 
    8282!> - Fix memory leaks bug 
    8383!> @date September, 2015 
     
    149149 
    150150   INTERFACE att_init 
    151       MODULE PROCEDURE att__init_c     
     151      MODULE PROCEDURE att__init_c 
    152152      MODULE PROCEDURE att__init_dp 
    153153      MODULE PROCEDURE att__init_dp_0d 
     
    170170 
    171171   INTERFACE att_clean 
    172       MODULE PROCEDURE att__clean_unit   
    173       MODULE PROCEDURE att__clean_arr    
     172      MODULE PROCEDURE att__clean_unit 
     173      MODULE PROCEDURE att__clean_arr 
    174174   END INTERFACE 
    175175 
     
    182182   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    183183   FUNCTION att__copy_arr(td_att) & 
    184          & RESULT(tf_att)       
     184         & RESULT(tf_att) 
    185185   !------------------------------------------------------------------- 
    186186   !> @brief 
    187187   !> This subroutine copy a array of attribute structure in another one 
    188    !> @details  
     188   !> @details 
    189189   !> see att__copy_unit 
    190190   !> 
     
    192192   !> attribute (ex: tl_att=att_copy(att_init()) is forbidden). 
    193193   !> This will create memory leaks. 
    194    !> @warning to avoid infinite loop, do not use any function inside  
     194   !> @warning to avoid infinite loop, do not use any function inside 
    195195   !> this subroutine 
    196196   !> 
     
    198198   !> @date November, 2013 - Initial Version 
    199199   !> @date November, 2014 
    200    !> - use function instead of overload assignment operator  
    201    !> (to avoid memory leak)  
    202    ! 
     200   !> - use function instead of overload assignment operator 
     201   !> (to avoid memory leak) 
     202   !> 
    203203   !> @param[in] td_att   array of attribute structure 
    204204   !> @return copy of input array of attribute structure 
     
    228228   !> @brief 
    229229   !> This subroutine copy an attribute structure in another one. 
    230    !> @details  
     230   !> @details 
    231231   !> attribute value are copied in a temporary array, so input and output 
    232232   !> attribute structure value do not point on the same "memory cell", and so 
    233    !> on are independant.  
     233   !> on are independant. 
    234234   !> 
    235235   !> @warning do not use on the output of a function who create or read an 
    236236   !> attribute (ex: tl_att=att_copy(att_init()) is forbidden). 
    237237   !> This will create memory leaks. 
    238    !> @warning to avoid infinite loop, do not use any function inside  
     238   !> @warning to avoid infinite loop, do not use any function inside 
    239239   !> this subroutine 
    240240   !> 
     
    242242   !> @date November, 2013 - Initial Version 
    243243   !> @date November, 2014 
    244    !> - use function instead of overload assignment operator (to avoid memory leak)  
     244   !> - use function instead of overload assignment operator (to avoid memory leak) 
    245245   !> 
    246246   !> @param[in] td_att   attribute structure 
     
    333333   !> @author J.Paul 
    334334   !> @date November, 2013 - Initial Version 
    335    !> @date September, 2014  
     335   !> @date September, 2014 
    336336   !> - bug fix with use of id read from attribute structure 
    337337   !> 
     
    372372   !------------------------------------------------------------------- 
    373373   !> @brief This function initialize an attribute structure with character 
    374    !> value.  
     374   !> value. 
    375375   !> 
    376376   !> @author J.Paul 
     
    391391      TYPE(TATT)                   :: tf_att 
    392392      !---------------------------------------------------------------- 
    393   
     393 
    394394      ! clean attribute 
    395395      CALL att_clean(tf_att) 
     
    410410         & RESULT (tf_att) 
    411411   !------------------------------------------------------------------- 
    412    !> @brief This function initialize an attribute structure with array  
     412   !> @brief This function initialize an attribute structure with array 
    413413   !> of real(8) value. 
    414414   !> @details 
     
    479479         & RESULT (tf_att) 
    480480   !------------------------------------------------------------------- 
    481    !> @brief This function initialize an attribute structure with  
    482    !> real(8) value  
     481   !> @brief This function initialize an attribute structure with 
     482   !> real(8) value 
    483483   !> @details 
    484484   !> Optionaly you could specify the type of the variable to be saved. 
     
    509509      ! clean attribute 
    510510      CALL att_clean(tf_att) 
    511        
     511 
    512512      cl_value="(/"//TRIM(fct_str(dd_value))//"/)" 
    513513 
     
    537537         & RESULT (tf_att) 
    538538   !------------------------------------------------------------------- 
    539    !> @brief This function initialize an attribute structure with array  
     539   !> @brief This function initialize an attribute structure with array 
    540540   !> of real(4) value. 
    541541   !> @details 
     
    571571      ! clean attribute 
    572572      CALL att_clean(tf_att) 
    573        
     573 
    574574      ! array size 
    575575      il_len=size(rd_value(:)) 
     
    586586      CALL logger_trace( & 
    587587      &  " ATT INIT: attribute name: "//TRIM(ADJUSTL(cd_name))//& 
    588       &  " attribute value "//TRIM(ADJUSTL(cl_value)) )       
     588      &  " attribute value "//TRIM(ADJUSTL(cl_value)) ) 
    589589 
    590590      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
     
    609609         & RESULT (tf_att) 
    610610   !------------------------------------------------------------------- 
    611    !> @brief This function initialize an attribute structure with  
    612    !> real(4) value.  
     611   !> @brief This function initialize an attribute structure with 
     612   !> real(4) value. 
    613613   !> @details 
    614614   !> Optionaly you could specify the type of the variable to be saved. 
     
    639639      ! clean attribute 
    640640      CALL att_clean(tf_att) 
    641        
     641 
    642642      cl_value="(/"//TRIM(fct_str(rd_value))//"/)" 
    643643 
    644644      CALL logger_trace( & 
    645645      &  " ATT INIT: attribute name: "//TRIM(ADJUSTL(cd_name))//& 
    646       &  " attribute value "//TRIM(ADJUSTL(cl_value)) )       
     646      &  " attribute value "//TRIM(ADJUSTL(cl_value)) ) 
    647647 
    648648      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
     
    667667         & RESULT (tf_att) 
    668668   !------------------------------------------------------------------- 
    669    !> @brief This function initialize an attribute structure with array  
     669   !> @brief This function initialize an attribute structure with array 
    670670   !> of integer(1) value. 
    671671   !> @details 
     
    701701      ! clean attribute 
    702702      CALL att_clean(tf_att) 
    703        
     703 
    704704      ! array size 
    705705      il_len=size(bd_value(:)) 
     
    713713      CALL logger_trace( & 
    714714      &  " ATT INIT: attribute name: "//TRIM(ADJUSTL(cd_name))//& 
    715       &  " attribute value "//TRIM(ADJUSTL(cl_value)) )       
     715      &  " attribute value "//TRIM(ADJUSTL(cl_value)) ) 
    716716 
    717717      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
     
    736736         & RESULT (tf_att) 
    737737   !------------------------------------------------------------------- 
    738    !> @brief This function initialize an attribute structure with  
    739    !> integer(1) value.  
     738   !> @brief This function initialize an attribute structure with 
     739   !> integer(1) value. 
    740740   !> @details 
    741741   !> Optionaly you could specify the type of the variable to be saved. 
     
    766766      ! clean attribute 
    767767      CALL att_clean(tf_att) 
    768        
     768 
    769769      cl_value="(/"//TRIM(fct_str(bd_value))//"/)" 
    770770 
    771771      CALL logger_trace( & 
    772772      &  " ATT INIT: attribute name: "//TRIM(ADJUSTL(cd_name))//& 
    773       &  " attibute value "//TRIM(ADJUSTL(cl_value)) )       
     773      &  " attibute value "//TRIM(ADJUSTL(cl_value)) ) 
    774774 
    775775      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
     
    779779      ELSE 
    780780         tf_att%i_type=NF90_BYTE 
    781       ENDIF       
     781      ENDIF 
    782782 
    783783      IF( ASSOCIATED(tf_att%d_value) )THEN 
     
    794794         & RESULT (tf_att) 
    795795   !------------------------------------------------------------------- 
    796    !> @brief This function initialize an attribute structure with array  
     796   !> @brief This function initialize an attribute structure with array 
    797797   !> of integer(2) value. 
    798798   !> @details 
     
    828828      ! clean attribute 
    829829      CALL att_clean(tf_att) 
    830        
     830 
    831831      ! array size 
    832832      il_len=size(sd_value(:)) 
     
    840840      CALL logger_trace( & 
    841841      &  " ATT INIT: attribute name: "//TRIM(ADJUSTL(cd_name))//& 
    842       &  " attribute value "//TRIM(ADJUSTL(cl_value)) )       
     842      &  " attribute value "//TRIM(ADJUSTL(cl_value)) ) 
    843843 
    844844      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
     
    863863         & RESULT (tf_att) 
    864864   !------------------------------------------------------------------- 
    865    !> @brief This function initialize an attribute structure with  
    866    !> integer(2) value.  
     865   !> @brief This function initialize an attribute structure with 
     866   !> integer(2) value. 
    867867   !> @details 
    868868   !> Optionaly you could specify the type of the variable to be saved. 
     
    893893      ! clean attribute 
    894894      CALL att_clean(tf_att) 
    895        
     895 
    896896      cl_value="(/"//TRIM(fct_str(sd_value))//"/)" 
    897897 
    898898      CALL logger_trace( & 
    899899      &  " ATT INIT: attribute name: "//TRIM(ADJUSTL(cd_name))//& 
    900       &  " attibute value "//TRIM(ADJUSTL(cl_value)) )       
     900      &  " attibute value "//TRIM(ADJUSTL(cl_value)) ) 
    901901 
    902902      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
     
    921921         & RESULT(tf_att) 
    922922   !------------------------------------------------------------------- 
    923    !> @brief This function initialize an attribute structure with array  
     923   !> @brief This function initialize an attribute structure with array 
    924924   !> of integer(4) value. 
    925925   !> @details 
     
    955955      ! clean attribute 
    956956      CALL att_clean(tf_att) 
    957        
     957 
    958958      ! array size 
    959959      il_len=size(id_value(:)) 
     
    967967      CALL logger_trace( & 
    968968      &  " ATT INIT: attribute name: "//TRIM(ADJUSTL(cd_name))//& 
    969       &  " attribute value "//TRIM(ADJUSTL(cl_value)) )       
     969      &  " attribute value "//TRIM(ADJUSTL(cl_value)) ) 
    970970 
    971971      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
     
    990990         & RESULT (tf_att) 
    991991   !------------------------------------------------------------------- 
    992    !> @brief This function initialize an attribute structure with  
    993    !> integer(4) value.  
     992   !> @brief This function initialize an attribute structure with 
     993   !> integer(4) value. 
    994994   !> @details 
    995995   !> Optionaly you could specify the type of the variable to be saved. 
     
    10201020      ! clean attribute 
    10211021      CALL att_clean(tf_att) 
    1022        
     1022 
    10231023      cl_value="(/"//TRIM(fct_str(id_value))//"/)" 
    10241024 
    10251025      CALL logger_trace( & 
    10261026      &  " ATT INIT: attribute name: "//TRIM(ADJUSTL(cd_name))//& 
    1027       &  " attibute value "//TRIM(ADJUSTL(cl_value)) )       
     1027      &  " attibute value "//TRIM(ADJUSTL(cl_value)) ) 
    10281028 
    10291029      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
     
    10481048         & RESULT (tf_att) 
    10491049   !------------------------------------------------------------------- 
    1050    !> @brief This function initialize an attribute structure with array  
     1050   !> @brief This function initialize an attribute structure with array 
    10511051   !> of integer(8) value. 
    10521052   !> @details 
     
    10821082      ! clean attribute 
    10831083      CALL att_clean(tf_att) 
    1084        
     1084 
    10851085      ! array size 
    10861086      il_len=size(kd_value(:)) 
     
    10941094      CALL logger_trace( & 
    10951095      &  " ATT INIT: attribute name: "//TRIM(ADJUSTL(cd_name))//& 
    1096       &  " attibute value "//TRIM(ADJUSTL(cl_value)) )       
     1096      &  " attibute value "//TRIM(ADJUSTL(cl_value)) ) 
    10971097 
    10981098      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
     
    11171117         & RESULT (tf_att) 
    11181118   !------------------------------------------------------------------- 
    1119    !> @brief This function initialize an attribute structure with  
    1120    !> integer(8) value.  
     1119   !> @brief This function initialize an attribute structure with 
     1120   !> integer(8) value. 
    11211121   !> @details 
    11221122   !> Optionaly you could specify the type of the variable to be saved. 
     
    11471147      ! clean attribute 
    11481148      CALL att_clean(tf_att) 
    1149        
     1149 
    11501150      cl_value="(/"//TRIM(fct_str(kd_value))//"/)" 
    11511151 
    11521152      CALL logger_trace( & 
    11531153      &  " ATT INIT: attribute name: "//TRIM(ADJUSTL(cd_name))//& 
    1154       &  " attibute value "//TRIM(ADJUSTL(cl_value)) )       
     1154      &  " attibute value "//TRIM(ADJUSTL(cl_value)) ) 
    11551155 
    11561156      tf_att%c_name=TRIM(ADJUSTL(cd_name)) 
     
    11741174   SUBROUTINE att__print_arr(td_att) 
    11751175   !------------------------------------------------------------------- 
    1176    !> @brief This subroutine print informations of an array of attribute.  
     1176   !> @brief This subroutine print informations of an array of attribute. 
    11771177   !> 
    11781178   !> @author J.Paul 
     
    11841184      IMPLICIT NONE 
    11851185 
    1186       ! Argument       
     1186      ! Argument 
    11871187      TYPE(TATT), DIMENSION(:), INTENT(IN) :: td_att 
    11881188 
     
    12031203   !> @author J.Paul 
    12041204   !> @date November, 2013 - Initial Version 
    1205    !> @date September, 2014  
     1205   !> @date September, 2014 
    12061206   !> - take into account type of attribute. 
    12071207   ! 
     
    12111211      IMPLICIT NONE 
    12121212 
    1213       ! Argument       
     1213      ! Argument 
    12141214      TYPE(TATT), INTENT(IN) :: td_att 
    12151215 
     
    12531253               cl_value=td_att%c_value 
    12541254 
    1255             CASE(NF90_BYTE)    
     1255            CASE(NF90_BYTE) 
    12561256               IF( td_att%i_len > 1 )THEN 
    12571257                  cl_value='(/' 
     
    12661266               ENDIF 
    12671267 
    1268             CASE(NF90_SHORT)    
     1268            CASE(NF90_SHORT) 
    12691269               IF( td_att%i_len > 1 )THEN 
    12701270                  cl_value='(/' 
     
    12791279               ENDIF 
    12801280 
    1281             CASE(NF90_INT)    
     1281            CASE(NF90_INT) 
    12821282               IF( td_att%i_len > 1 )THEN 
    12831283                  cl_value='(/' 
     
    12921292               ENDIF 
    12931293 
    1294             CASE(NF90_FLOAT)    
     1294            CASE(NF90_FLOAT) 
    12951295               IF( td_att%i_len > 1 )THEN 
    12961296                  cl_value='(/' 
     
    13051305               ENDIF 
    13061306 
    1307             CASE(NF90_DOUBLE)    
     1307            CASE(NF90_DOUBLE) 
    13081308               IF( td_att%i_len > 1 )THEN 
    13091309                  cl_value='(/' 
     
    13331333   SUBROUTINE att__clean_unit(td_att) 
    13341334   !------------------------------------------------------------------- 
    1335    !> @brief  
     1335   !> @brief 
    13361336   !>  This subroutine clean attribute strcuture. 
    13371337   ! 
    13381338   !> @author J.Paul 
    13391339   !> @date November, 2013 - Initial Version 
    1340    !> @date January, 2019  
     1340   !> @date January, 2019 
    13411341   !> - nullify array inside attribute structure 
    13421342   !> 
     
    13691369   SUBROUTINE att__clean_arr(td_att) 
    13701370   !------------------------------------------------------------------- 
    1371    !> @brief  
     1371   !> @brief 
    13721372   !>  This subroutine clean array of attribute strcuture. 
    13731373   ! 
     
    14031403   !> - close file (bugfix) 
    14041404   !> @date May, 2019 
    1405    !> - read number of dummy element  
     1405   !> - read number of dummy element 
    14061406   !> 
    14071407   !> @param[in] cd_dummy dummy configuration file 
     
    14421442      INQUIRE(FILE=TRIM(cd_dummy), EXIST=ll_exist) 
    14431443      IF( ll_exist )THEN 
    1444      
     1444 
    14451445         il_fileid=fct_getunit() 
    1446     
     1446 
    14471447         OPEN( il_fileid, FILE=TRIM(cd_dummy), & 
    14481448         &                FORM='FORMATTED',       & 
     
    14551455            CALL logger_fatal("DIM GET DUMMY: opening "//TRIM(cd_dummy)) 
    14561456         ENDIF 
    1457     
     1457 
    14581458         READ( il_fileid, NML = namdum ) 
    14591459         im_ndumatt  = in_ndumatt 
     
    14691469 
    14701470      ENDIF 
    1471     
     1471 
    14721472   END SUBROUTINE att_get_dummy 
    14731473   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     
    14891489      IMPLICIT NONE 
    14901490 
    1491       ! Argument       
     1491      ! Argument 
    14921492      TYPE(TATT), INTENT(IN) :: td_att 
    1493        
     1493 
    14941494      ! function 
    14951495      LOGICAL                :: lf_dummy 
    1496        
     1496 
    14971497      ! loop indices 
    14981498      INTEGER(i4) :: ji 
  • utils/tools/SIREN/src/boundary.f90

    r12080 r13369  
    106106!> 
    107107!> @date November, 2013 - Initial Version 
    108 !> @date September, 2014  
     108!> @date September, 2014 
    109109!> - add boundary description 
    110 !> @date November, 2014  
     110!> @date November, 2014 
    111111!> - Fix memory leaks bug 
    112 !> @date February, 2015  
     112!> @date February, 2015 
    113113!> - Do not change indices read from namelist 
    114 !> - Change string character format of boundary read from namelist,  
     114!> - Change string character format of boundary read from namelist, 
    115115!>  see boundary__get_info 
    116 !>  
     116!> 
    117117!> @todo add schematic to boundary structure description 
    118 !>  
     118!> 
    119119!> @note Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt) 
    120120!---------------------------------------------------------------------- 
    121121MODULE boundary 
    122122 
    123    USE netcdf                          ! nf90 library                            
     123   USE netcdf                          ! nf90 library 
    124124   USE global                          ! global parameter 
    125125   USE phycst                          ! physical constant 
     
    143143   PUBLIC :: boundary_init         !< initialise boundary structure 
    144144   PUBLIC :: boundary_print        !< print information about boundary 
    145    PUBLIC :: boundary_clean        !< clean boundary structure  
     145   PUBLIC :: boundary_clean        !< clean boundary structure 
    146146   PUBLIC :: boundary_get_indices  !< get indices of each semgent for each boundary. 
    147147   PUBLIC :: boundary_check        !< check boundary indices and corner. 
     
    150150   PUBLIC :: boundary_swap         !< swap array for north and east boundary 
    151151 
    152    PRIVATE :: boundary__clean_unit      ! clean boundary structure  
    153    PRIVATE :: boundary__clean_arr       ! clean array of boundary structure  
     152   PRIVATE :: boundary__clean_unit      ! clean boundary structure 
     153   PRIVATE :: boundary__clean_arr       ! clean array of boundary structure 
    154154   PRIVATE :: boundary__init_wrapper    ! initialise a boundary structure 
    155155   PRIVATE :: boundary__init            ! initialise basically a boundary structure 
    156156   PRIVATE :: boundary__copy_unit       ! copy boundary structure in another 
    157157   PRIVATE :: boundary__copy_arr        ! copy boundary structure in another 
    158    PRIVATE :: boundary__add_seg         ! add one segment structure to a boundary  
     158   PRIVATE :: boundary__add_seg         ! add one segment structure to a boundary 
    159159   PRIVATE :: boundary__del_seg         ! remove all segments of a boundary 
    160160   PRIVATE :: boundary__get_info        ! get boundary information from boundary description string character. 
    161161   PRIVATE :: boundary__get_seg_number  ! compute the number of sea segment for one boundary 
    162    PRIVATE :: boundary__get_seg_indices ! get segment indices for one boundary  
     162   PRIVATE :: boundary__get_seg_indices ! get segment indices for one boundary 
    163163   PRIVATE :: boundary__print_unit      ! print information about one boundary 
    164164   PRIVATE :: boundary__print_arr       ! print information about a array of boundary 
    165     
     165 
    166166   PRIVATE :: seg__init       ! initialise segment structure 
    167167   PRIVATE :: seg__clean      ! clean segment structure 
     
    175175      INTEGER(i4) :: i_index = 0 !< segment index 
    176176      INTEGER(i4) :: i_width = 0 !< segment width 
    177       INTEGER(i4) :: i_first = 0 !< segment first indice  
     177      INTEGER(i4) :: i_first = 0 !< segment first indice 
    178178      INTEGER(i4) :: i_last  = 0 !< segment last indices 
    179179   END TYPE TSEG 
     
    181181   TYPE TBDY !< boundary structure 
    182182      CHARACTER(LEN=lc) :: c_card = ''          !< boundary cardinal 
    183       LOGICAL           :: l_use  = .FALSE.     !< boundary use or not  
     183      LOGICAL           :: l_use  = .FALSE.     !< boundary use or not 
    184184      LOGICAL           :: l_nam  = .FALSE.     !< boundary get from namelist 
    185185      INTEGER(i4)       :: i_nseg = 0           !< number of segment in boundary 
     
    191191 
    192192   INTERFACE boundary_init 
    193       MODULE PROCEDURE boundary__init_wrapper  
     193      MODULE PROCEDURE boundary__init_wrapper 
    194194   END INTERFACE boundary_init 
    195195 
    196196   INTERFACE boundary_print 
    197       MODULE PROCEDURE boundary__print_unit  
    198       MODULE PROCEDURE boundary__print_arr  
     197      MODULE PROCEDURE boundary__print_unit 
     198      MODULE PROCEDURE boundary__print_arr 
    199199   END INTERFACE boundary_print 
    200200 
    201201   INTERFACE boundary_clean 
    202       MODULE PROCEDURE boundary__clean_unit    
    203       MODULE PROCEDURE boundary__clean_arr     
     202      MODULE PROCEDURE boundary__clean_unit 
     203      MODULE PROCEDURE boundary__clean_arr 
    204204   END INTERFACE 
    205205 
    206206   INTERFACE seg__clean 
    207       MODULE PROCEDURE seg__clean_unit    
    208       MODULE PROCEDURE seg__clean_arr     
     207      MODULE PROCEDURE seg__clean_unit 
     208      MODULE PROCEDURE seg__clean_arr 
    209209   END INTERFACE 
    210210 
    211211   INTERFACE boundary_copy 
    212       MODULE PROCEDURE boundary__copy_unit  
    213       MODULE PROCEDURE boundary__copy_arr  
    214    END INTERFACE    
     212      MODULE PROCEDURE boundary__copy_unit 
     213      MODULE PROCEDURE boundary__copy_arr 
     214   END INTERFACE 
    215215 
    216216   INTERFACE seg__copy 
    217217      MODULE PROCEDURE seg__copy_unit   ! copy segment structure 
    218218      MODULE PROCEDURE seg__copy_arr    ! copy array of segment structure 
    219    END INTERFACE    
     219   END INTERFACE 
    220220 
    221221CONTAINS 
     
    226226   !> @brief 
    227227   !> This subroutine copy a array of boundary structure in another one 
    228    !> @details  
     228   !> @details 
    229229   !> 
    230230   !> @warning do not use on the output of a function who create or read an 
    231231   !> attribute (ex: tl_bdy=boundary_copy(boundary_init()) is forbidden). 
    232232   !> This will create memory leaks. 
    233    !> @warning to avoid infinite loop, do not use any function inside  
     233   !> @warning to avoid infinite loop, do not use any function inside 
    234234   !> this subroutine 
    235235   !> 
     
    237237   !> @date November, 2013 - Initial Version 
    238238   !> @date November, 2014 
    239    !> - use function instead of overload assignment operator  
     239   !> - use function instead of overload assignment operator 
    240240   !> (to avoid memory leak) 
    241241   ! 
    242242   !> @param[in] td_bdy   array of boundary structure 
    243    !> @return copy of input array of boundary structure  
     243   !> @return copy of input array of boundary structure 
    244244   !------------------------------------------------------------------- 
    245245 
     
    268268   !> @brief 
    269269   !> This subroutine copy boundary structure in another one 
    270    !> @details  
     270   !> @details 
    271271   !> 
    272272   !> @warning do not use on the output of a function who create or read an 
    273273   !> attribute (ex: tl_bdy=boundary_copy(boundary_init()) is forbidden). 
    274274   !> This will create memory leaks. 
    275    !> @warning to avoid infinite loop, do not use any function inside  
     275   !> @warning to avoid infinite loop, do not use any function inside 
    276276   !> this subroutine 
    277277   !> 
     
    279279   !> @date November, 2013 - Initial Version 
    280280   !> @date November, 2014 
    281    !> - use function instead of overload assignment operator  
     281   !> - use function instead of overload assignment operator 
    282282   !> (to avoid memory leak) 
    283283   ! 
     
    325325   !> @date November, 2013 - Initial Version 
    326326   !> @date January, 2019 
    327    !> - nullify segment structure inside boundary structure  
     327   !> - nullify segment structure inside boundary structure 
    328328   ! 
    329329   !> @param[inout] td_bdy boundary strucutre 
     
    385385   FUNCTION boundary_set_filename(cd_file, cd_card, id_seg, cd_date) & 
    386386         &  RESULT (cf_file) 
    387    !-------------------------------------------------------------------  
     387   !------------------------------------------------------------------- 
    388388   !> @brief This function put cardinal name and date inside file name. 
    389    !  
    390    !> @details  
     389   ! 
     390   !> @details 
    391391   !>    Examples : 
    392392   !>       cd_file="boundary.nc" 
    393    !>       cd_card="west"  
     393   !>       cd_card="west" 
    394394   !>       id_seg =2 
    395395   !>       cd_date=y2015m07d16 
    396    !>  
     396   !> 
    397397   !>       function return "boundary_west_2_y2015m07d16.nc" 
    398    !>  
     398   !> 
    399399   !>       cd_file="boundary.nc" 
    400    !>       cd_card="west"  
    401    !>  
     400   !>       cd_card="west" 
     401   !> 
    402402   !>       function return "boundary_west.nc" 
    403    !>  
    404    !> @author J.Paul  
    405    !> @date November, 2013 - Initial Version  
    406    !  
    407    !> @param[in] cd_file   file name  
    408    !> @param[in] cd_card   cardinal name  
    409    !> @param[in] id_seg    segment number  
    410    !> @param[in] cd_date   file date (format: y????m??d??)  
     403   !> 
     404   !> @author J.Paul 
     405   !> @date November, 2013 - Initial Version 
     406   ! 
     407   !> @param[in] cd_file   file name 
     408   !> @param[in] cd_card   cardinal name 
     409   !> @param[in] id_seg    segment number 
     410   !> @param[in] cd_date   file date (format: y????m??d??) 
    411411   !> @return file name with cardinal name inside 
    412    !-------------------------------------------------------------------  
    413  
    414       IMPLICIT NONE  
     412   !------------------------------------------------------------------- 
     413 
     414      IMPLICIT NONE 
    415415 
    416416      ! Argument 
     
    420420      CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_date 
    421421 
    422       ! function  
     422      ! function 
    423423      CHARACTER(LEN=lc)            :: cf_file 
    424424 
    425       ! local variable  
     425      ! local variable 
    426426      CHARACTER(LEN=lc) :: cl_dirname 
    427427      CHARACTER(LEN=lc) :: cl_basename 
     
    435435      INTEGER(i4)       :: il_indend 
    436436 
    437       ! loop indices  
    438       !----------------------------------------------------------------  
     437      ! loop indices 
     438      !---------------------------------------------------------------- 
    439439      ! init 
    440440      cf_file='' 
     
    449449         cl_base  =fct_split(TRIM(cl_basename),1,'.') 
    450450         cl_suffix=fct_split(TRIM(cl_basename),2,'.') 
    451           
     451 
    452452         ! add segment number 
    453453         IF( PRESENT(id_seg) )THEN 
     
    483483         &  " are empty") 
    484484      ENDIF 
    485   
    486    END FUNCTION boundary_set_filename  
     485 
     486   END FUNCTION boundary_set_filename 
    487487   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    488488   FUNCTION boundary__init_wrapper(td_var,                               & 
     
    491491         &                         ld_oneseg) & 
    492492         &  RESULT (tf_bdy) 
    493    !-------------------------------------------------------------------  
     493   !------------------------------------------------------------------- 
    494494   !> @brief This function initialise a boundary structure. 
    495    !  
    496    !> @details  
     495   ! 
     496   !> @details 
    497497   !>  Boundaries for each cardinal will be compute with variable structure. 
    498    !>  It means that orthogonal index, first and last indices of each  
     498   !>  It means that orthogonal index, first and last indices of each 
    499499   !>  sea segment will be compute automatically. 
    500500   !>  However you could specify which boundary to use or not with 
     
    502502   !>  And boundary description could be specify with argument 
    503503   !>  cn_north, cn_south, cn_east, cn_west. 
    504    !>  For each cardinal you could specify orthogonal index,  
     504   !>  For each cardinal you could specify orthogonal index, 
    505505   !>  first and last indices (in this order) and boundary width (between 
    506506   !>  parentheses). 
    507507   !> ex : cn_north='index,first,last(width)' 
    508    !> You could specify more than one segment for each boundary.  
     508   !> You could specify more than one segment for each boundary. 
    509509   !> However each segment will have the same width. So you do not need to 
    510510   !> specify it for each segment. 
     
    512512   !> 
    513513   !> @warn Boundaries are compute on T point, but expressed on U,V point. 
    514    !> change will be done to get data on other point when need be.  
     514   !> change will be done to get data on other point when need be. 
    515515   !> 
    516    !> @author J.Paul  
    517    !> @date November, 2013 - Initial Version  
     516   !> @author J.Paul 
     517   !> @date November, 2013 - Initial Version 
    518518   !> @date September, 2014 
    519519   !> - add boolean to use only one segment for each boundary 
    520520   !> - check boundary width 
    521    !  
    522    !> @param[in] td_var    variable structure  
    523    !> @param[in] ld_north  use north boundary or not  
    524    !> @param[in] ld_south  use south boundary or not  
    525    !> @param[in] ld_east   use east  boundary or not  
    526    !> @param[in] ld_west   use west  boundary or not  
    527    !> @param[in] cd_north  north boundary description  
    528    !> @param[in] cd_south  south boundary description  
    529    !> @param[in] cd_east   east  boundary description  
    530    !> @param[in] cd_west   west  boundary description  
    531    !> @param[in] ld_oneseg force to use only one segment for each boundary  
     521   ! 
     522   !> @param[in] td_var    variable structure 
     523   !> @param[in] ld_north  use north boundary or not 
     524   !> @param[in] ld_south  use south boundary or not 
     525   !> @param[in] ld_east   use east  boundary or not 
     526   !> @param[in] ld_west   use west  boundary or not 
     527   !> @param[in] cd_north  north boundary description 
     528   !> @param[in] cd_south  south boundary description 
     529   !> @param[in] cd_east   east  boundary description 
     530   !> @param[in] cd_west   west  boundary description 
     531   !> @param[in] ld_oneseg force to use only one segment for each boundary 
    532532   !> @return boundary structure 
    533    !-------------------------------------------------------------------  
    534  
    535       IMPLICIT NONE  
     533   !------------------------------------------------------------------- 
     534 
     535      IMPLICIT NONE 
    536536 
    537537      ! Argument 
     
    539539      LOGICAL          , INTENT(IN), OPTIONAL :: ld_north 
    540540      LOGICAL          , INTENT(IN), OPTIONAL :: ld_south 
    541       LOGICAL          , INTENT(IN), OPTIONAL :: ld_east  
    542       LOGICAL          , INTENT(IN), OPTIONAL :: ld_west  
     541      LOGICAL          , INTENT(IN), OPTIONAL :: ld_east 
     542      LOGICAL          , INTENT(IN), OPTIONAL :: ld_west 
    543543      CHARACTER(LEN=lc), INTENT(IN), OPTIONAL :: cd_north 
    544544      CHARACTER(LEN=lc), INTENT(IN), OPTIONAL :: cd_south 
    545       CHARACTER(LEN=lc), INTENT(IN), OPTIONAL :: cd_east  
     545      CHARACTER(LEN=lc), INTENT(IN), OPTIONAL :: cd_east 
    546546      CHARACTER(LEN=lc), INTENT(IN), OPTIONAL :: cd_west 
    547       LOGICAL          , INTENT(IN), OPTIONAL :: ld_oneseg  
    548  
    549       ! function  
     547      LOGICAL          , INTENT(IN), OPTIONAL :: ld_oneseg 
     548 
     549      ! function 
    550550      TYPE(TBDY)       , DIMENSION(ip_ncard)  :: tf_bdy 
    551551 
    552       ! local variable  
     552      ! local variable 
    553553      INTEGER(i4)                            :: il_width 
    554554      INTEGER(i4)      , DIMENSION(ip_ncard) :: il_max_width 
     
    565565      LOGICAL                                :: ll_oneseg 
    566566 
    567       ! loop indices  
     567      ! loop indices 
    568568      INTEGER(i4) :: ji 
    569569      INTEGER(i4) :: jk 
    570       !----------------------------------------------------------------  
     570      !---------------------------------------------------------------- 
    571571      IF( .NOT. ASSOCIATED(td_var%d_value) )THEN 
    572572         CALL logger_error("BOUNDARY INIT: no value associated to variable "//& 
     
    612612         il_max(jp_east )=td_var%t_dim(2)%i_len 
    613613         il_max(jp_west )=td_var%t_dim(2)%i_len 
    614   
     614 
    615615         cl_card=(/'','','',''/) 
    616616         IF( PRESENT(cd_north) ) cl_card(jp_north)=TRIM(cd_north) 
     
    663663               ELSE 
    664664                  ! fill undefined value 
    665                   WHERE( tf_bdy(jk)%t_seg(:)%i_index == 0 )  
     665                  WHERE( tf_bdy(jk)%t_seg(:)%i_index == 0 ) 
    666666                     tf_bdy(jk)%t_seg(:)%i_index = tl_seg%i_index 
    667                   END WHERE                
    668                   WHERE( tf_bdy(jk)%t_seg(:)%i_width == 0 )  
     667                  END WHERE 
     668                  WHERE( tf_bdy(jk)%t_seg(:)%i_width == 0 ) 
    669669                     tf_bdy(jk)%t_seg(:)%i_width = tl_seg%i_width 
    670670                  END WHERE 
    671                   WHERE( tf_bdy(jk)%t_seg(:)%i_first == 0 )  
     671                  WHERE( tf_bdy(jk)%t_seg(:)%i_first == 0 ) 
    672672                     tf_bdy(jk)%t_seg(:)%i_first = tl_seg%i_first 
    673673                  END WHERE 
    674                   WHERE( tf_bdy(jk)%t_seg(:)%i_last == 0 )  
     674                  WHERE( tf_bdy(jk)%t_seg(:)%i_last == 0 ) 
    675675                     tf_bdy(jk)%t_seg(:)%i_last = tl_seg%i_last 
    676676                  END WHERE 
     
    688688 
    689689      ENDIF 
    690   
    691    END FUNCTION boundary__init_wrapper  
     690 
     691   END FUNCTION boundary__init_wrapper 
    692692   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    693693   FUNCTION boundary__init(cd_card, ld_use, ld_nam, td_seg) & 
    694694         &  RESULT (tf_bdy) 
    695    !-------------------------------------------------------------------  
     695   !------------------------------------------------------------------- 
    696696   !> @brief This function initialise basically a boundary structure with 
    697697   !> cardinal name. 
    698    !  
    699    !> @details  
    700    !> optionnaly you could specify if this boundary is used or not,  
     698   ! 
     699   !> @details 
     700   !> optionnaly you could specify if this boundary is used or not, 
    701701   !> and add one segment structure. 
    702    !  
    703    !> @author J.Paul  
    704    !> @date November, 2013 - Initial Version  
    705    !  
     702   ! 
     703   !> @author J.Paul 
     704   !> @date November, 2013 - Initial Version 
     705   ! 
    706706   !> @param[in]  cd_card  cardinal name 
    707707   !> @param[in]  ld_use   boundary use or not 
    708708   !> @param[in]  td_seg   segment structure 
    709709   !> @return boundary structure 
    710    !-------------------------------------------------------------------  
    711  
    712       IMPLICIT NONE  
     710   !------------------------------------------------------------------- 
     711 
     712      IMPLICIT NONE 
    713713 
    714714      ! Argument 
    715715      CHARACTER(LEN=*), INTENT(IN) :: cd_card 
    716       LOGICAL         , INTENT(IN), OPTIONAL :: ld_use  
    717       LOGICAL         , INTENT(IN), OPTIONAL :: ld_nam  
     716      LOGICAL         , INTENT(IN), OPTIONAL :: ld_use 
     717      LOGICAL         , INTENT(IN), OPTIONAL :: ld_nam 
    718718      TYPE(TSEG)      , INTENT(IN), OPTIONAL :: td_seg 
    719719 
    720       ! function  
     720      ! function 
    721721      TYPE(TBDY)                   :: tf_bdy 
    722722 
    723       ! local variable  
    724       ! loop indices  
    725       !----------------------------------------------------------------  
     723      ! local variable 
     724      ! loop indices 
     725      !---------------------------------------------------------------- 
    726726 
    727727      SELECT CASE(TRIM(cd_card)) 
    728728         CASE ('north','south','east','west') 
    729           
     729 
    730730            tf_bdy%c_card=TRIM(cd_card) 
    731731 
     
    746746   END FUNCTION boundary__init 
    747747   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    748    SUBROUTINE boundary__add_seg(td_bdy, td_seg)  
    749    !-------------------------------------------------------------------  
    750    !> @brief This subroutine add one segment structure to a boundary structure  
    751    !  
    752    !> @details  
    753    !  
    754    !> @author J.Paul  
    755    !> @date November, 2013 - Initial Version  
    756    !  
    757    !> @param[inout] td_bdy boundary structure   
    758    !> @param[in] td_seg    segment structure   
    759    !-------------------------------------------------------------------  
    760  
    761       IMPLICIT NONE  
    762  
    763       ! Argument  
     748   SUBROUTINE boundary__add_seg(td_bdy, td_seg) 
     749   !------------------------------------------------------------------- 
     750   !> @brief This subroutine add one segment structure to a boundary structure 
     751   ! 
     752   !> @details 
     753   ! 
     754   !> @author J.Paul 
     755   !> @date November, 2013 - Initial Version 
     756   ! 
     757   !> @param[inout] td_bdy boundary structure 
     758   !> @param[in] td_seg    segment structure 
     759   !------------------------------------------------------------------- 
     760 
     761      IMPLICIT NONE 
     762 
     763      ! Argument 
    764764      TYPE(TBDY), INTENT(INOUT) :: td_bdy 
    765765      TYPE(TSEG), INTENT(IN   ) :: td_seg 
    766766 
    767       ! local variable  
     767      ! local variable 
    768768      INTEGER(i4)                            :: il_status 
    769769      TYPE(TSEG) , DIMENSION(:), ALLOCATABLE :: tl_seg 
    770770 
    771       ! loop indices  
    772       !----------------------------------------------------------------  
     771      ! loop indices 
     772      !---------------------------------------------------------------- 
    773773 
    774774      IF( td_bdy%i_nseg > 0 )THEN 
     
    795795            ! clean 
    796796            CALL seg__clean(tl_seg(:)) 
    797             DEALLOCATE(tl_seg)             
    798              
     797            DEALLOCATE(tl_seg) 
     798 
    799799         ENDIF 
    800800      ELSE 
     
    808808            CALL logger_error( & 
    809809            &  " BOUNDARY ADD SEG: not enough space to put segments ") 
    810          ENDIF          
     810         ENDIF 
    811811      ENDIF 
    812   
     812 
    813813      ! update number of segment 
    814814      td_bdy%i_nseg=td_bdy%i_nseg+1 
     
    817817      td_bdy%t_seg(td_bdy%i_nseg)=seg__copy(td_seg) 
    818818 
    819    END SUBROUTINE boundary__add_seg  
    820    !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    821    SUBROUTINE boundary__del_seg(td_bdy)  
    822    !-------------------------------------------------------------------  
    823    !> @brief This subroutine remove all segments of a boundary structure  
    824    !  
    825    !> @details  
    826    !  
    827    !> @author J.Paul  
    828    !> @date November, 2013 - Initial Version  
    829    !  
     819   END SUBROUTINE boundary__add_seg 
     820   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     821   SUBROUTINE boundary__del_seg(td_bdy) 
     822   !------------------------------------------------------------------- 
     823   !> @brief This subroutine remove all segments of a boundary structure 
     824   ! 
     825   !> @details 
     826   ! 
     827   !> @author J.Paul 
     828   !> @date November, 2013 - Initial Version 
     829   ! 
    830830   !> @param[inout]  td_bdy   boundary structure 
    831    !-------------------------------------------------------------------  
    832  
    833       IMPLICIT NONE  
    834  
    835       ! Argument  
     831   !------------------------------------------------------------------- 
     832 
     833      IMPLICIT NONE 
     834 
     835      ! Argument 
    836836      TYPE(TBDY), INTENT(INOUT) :: td_bdy 
    837837 
    838       ! local variable  
    839       ! loop indices  
    840       !----------------------------------------------------------------  
     838      ! local variable 
     839      ! loop indices 
     840      !---------------------------------------------------------------- 
    841841 
    842842      IF( ASSOCIATED(td_bdy%t_seg) )THEN 
     
    847847      td_bdy%i_nseg=0 
    848848 
    849    END SUBROUTINE boundary__del_seg  
     849   END SUBROUTINE boundary__del_seg 
    850850   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    851851   FUNCTION boundary__get_info(cd_card, id_jcard) & 
    852852         & RESULT (tf_bdy) 
    853    !-------------------------------------------------------------------  
    854    !> @brief This function get information about boundary from string character.  
    855    !  
     853   !------------------------------------------------------------------- 
     854   !> @brief This function get information about boundary from string character. 
     855   ! 
    856856   !> @details 
    857857   !> This string character that will be passed through namelist could contains 
    858    !> orthogonal index, first and last indices, of each segment.  
     858   !> orthogonal index, first and last indices, of each segment. 
    859859   !> And also the width of all segments of this boundary. 
    860860   !>   cn_north='index1,first1:last1(width)|index2,first2:last2' 
    861    !>  
    862    !> @author J.Paul  
    863    !> @date November, 2013 - Initial Version  
    864    !> @date february, 2015  
     861   !> 
     862   !> @author J.Paul 
     863   !> @date November, 2013 - Initial Version 
     864   !> @date february, 2015 
    865865   !> - do not change indices read from namelist 
    866866   !> - change format cn_north 
    867    !  
     867   ! 
    868868   !> @param[in] cd_card   boundary description 
    869869   !> @param[in] id_jcard  boundary index 
    870870   !> @return boundary structure 
    871    !-------------------------------------------------------------------  
    872  
    873       IMPLICIT NONE  
    874  
    875       ! Argument  
     871   !------------------------------------------------------------------- 
     872 
     873      IMPLICIT NONE 
     874 
     875      ! Argument 
    876876      CHARACTER(LEN=lc), INTENT(IN) :: cd_card 
    877877      INTEGER(i4)      , INTENT(IN) :: id_jcard 
    878878 
    879       ! function  
     879      ! function 
    880880      TYPE(TBDY)                    :: tf_bdy 
    881881 
    882       ! local variable  
     882      ! local variable 
    883883      INTEGER(i4)       :: il_width 
    884884      INTEGER(i4)       :: il_ind1 
     
    890890      CHARACTER(LEN=lc) :: cl_tmp 
    891891      CHARACTER(LEN=lc) :: cl_first 
    892       CHARACTER(LEN=lc) :: cl_last  
     892      CHARACTER(LEN=lc) :: cl_last 
    893893 
    894894      TYPE(TSEG)        :: tl_seg 
    895895 
    896       ! loop indices  
     896      ! loop indices 
    897897      INTEGER(i4) :: ji 
    898       !----------------------------------------------------------------  
    899   
     898      !---------------------------------------------------------------- 
     899 
    900900      ji=1 
    901901      cl_seg=fct_split(cd_card,ji) 
    902902 
    903903      il_width=0 
    904       ! look for segment width  
     904      ! look for segment width 
    905905      ! width should be the same for all segment of one boundary 
    906906      IF( TRIM(cl_seg)   /= '' )THEN 
     
    924924         ENDIF 
    925925 
    926       ENDIF  
     926      ENDIF 
    927927 
    928928      DO WHILE( TRIM(cl_seg) /= '' ) 
     
    940940            ENDIF 
    941941         ENDIF 
    942        
    943           
     942 
     943 
    944944         cl_tmp=fct_split(cl_seg,2,',') 
    945945 
     
    956956               &  " check namelist. ") 
    957957            ENDIF 
    958          ENDIF          
    959           
     958         ENDIF 
     959 
    960960         cl_last =fct_split(cl_tmp,2,':') 
    961961         ! remove potential width information 
     
    996996         ! clean 
    997997         CALL seg__clean(tl_seg) 
    998       ENDDO  
    999  
    1000    END FUNCTION boundary__get_info  
    1001    !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    1002    SUBROUTINE boundary_get_indices(td_bdy, td_var, ld_oneseg)  
    1003    !-------------------------------------------------------------------  
     998      ENDDO 
     999 
     1000   END FUNCTION boundary__get_info 
     1001   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1002   SUBROUTINE boundary_get_indices(td_bdy, td_var, ld_oneseg) 
     1003   !------------------------------------------------------------------- 
    10041004   !> @brief This subroutine get indices of each semgent for each boundary. 
    1005    !  
    1006    !> @details  
     1005   ! 
     1006   !> @details 
    10071007   !> indices are compute from variable value, actually variable fill value, 
    1008    !> which is assume to be land mask.  
    1009    !> Boundary structure should have been initialized before running  
     1008   !> which is assume to be land mask. 
     1009   !> Boundary structure should have been initialized before running 
    10101010   !> this subroutine. Segment indices will be search between first and last 
    10111011   !> indies, at this orthogonal index. 
    1012    !>  
     1012   !> 
    10131013   !> Optionnally you could forced to use only one segment for each boundary. 
    1014    !>  
    1015    !> @warning number of segment (i_nseg) will be change, before the number  
     1014   !> 
     1015   !> @warning number of segment (i_nseg) will be change, before the number 
    10161016   !> of segment structure 
    1017    !  
    1018    !> @author J.Paul  
    1019    !> @date November, 2013 - Initial Version  
    1020    !  
    1021    !> @param[inout] td_bdy boundary structure   
    1022    !> @param[in] td_var    variable structure  
    1023    !> @param[in] ld_onseg  use only one sgment for each boundary  
    1024    !-------------------------------------------------------------------  
    1025  
    1026       IMPLICIT NONE  
     1017   ! 
     1018   !> @author J.Paul 
     1019   !> @date November, 2013 - Initial Version 
     1020   ! 
     1021   !> @param[inout] td_bdy boundary structure 
     1022   !> @param[in] td_var    variable structure 
     1023   !> @param[in] ld_onseg  use only one sgment for each boundary 
     1024   !------------------------------------------------------------------- 
     1025 
     1026      IMPLICIT NONE 
    10271027 
    10281028      ! Argument 
     
    10311031      LOGICAL                         , INTENT(IN   ), OPTIONAL :: ld_oneseg 
    10321032 
    1033       ! local variable  
     1033      ! local variable 
    10341034      INTEGER(i4) :: il_index 
    10351035      INTEGER(i4) :: il_width 
    10361036      INTEGER(i4) :: il_first 
    1037       INTEGER(i4) :: il_last  
     1037      INTEGER(i4) :: il_last 
    10381038 
    10391039      LOGICAL     :: ll_oneseg 
     
    10431043      ! loop indices 
    10441044      INTEGER(i4) :: jk 
    1045       !----------------------------------------------------------------  
    1046   
     1045      !---------------------------------------------------------------- 
     1046 
    10471047      ll_oneseg=.TRUE. 
    10481048      IF( PRESENT(ld_oneseg) ) ll_oneseg=ld_oneseg 
     
    10631063               il_first=td_bdy(jk)%t_seg(1)%i_first 
    10641064               il_last =td_bdy(jk)%t_seg(1)%i_last 
    1065   
     1065 
    10661066               CALL boundary__get_seg_number( td_bdy(jk), td_var) 
    10671067 
     
    10911091      ENDDO 
    10921092 
    1093    END SUBROUTINE boundary_get_indices  
    1094    !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    1095    SUBROUTINE boundary__get_seg_number(td_bdy, td_var)  
    1096    !-------------------------------------------------------------------  
    1097    !> @brief This subroutine compute the number of sea segment.  
    1098    !  
    1099    !> @details  
     1093   END SUBROUTINE boundary_get_indices 
     1094   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1095   SUBROUTINE boundary__get_seg_number(td_bdy, td_var) 
     1096   !------------------------------------------------------------------- 
     1097   !> @brief This subroutine compute the number of sea segment. 
     1098   ! 
     1099   !> @details 
    11001100   !> It use variable value, actually variable fill value 
    11011101   !> (which is assume to be land mask), to compute the number of segment between 
    11021102   !> first and last indices at boundary orthogonal index. 
    1103    !> @warning number of segment (i_nseg) will be change, before the number  
     1103   !> @warning number of segment (i_nseg) will be change, before the number 
    11041104   !> of segment structure 
    1105    !  
    1106    !> @author J.Paul  
    1107    !> @date November, 2013 - Initial Version  
    1108    !  
    1109    !> @param[inout] td_bdy boundary structure  
    1110    !> @param[in] td_var    variable structure  
    1111    !-------------------------------------------------------------------  
    1112  
    1113       IMPLICIT NONE  
     1105   ! 
     1106   !> @author J.Paul 
     1107   !> @date November, 2013 - Initial Version 
     1108   ! 
     1109   !> @param[inout] td_bdy boundary structure 
     1110   !> @param[in] td_var    variable structure 
     1111   !------------------------------------------------------------------- 
     1112 
     1113      IMPLICIT NONE 
    11141114 
    11151115      ! Argument 
     
    11171117      TYPE(TVAR) , INTENT(IN   ) :: td_var 
    11181118 
    1119       ! local variable  
     1119      ! local variable 
    11201120      REAL(dp)   , DIMENSION(:)        , ALLOCATABLE :: dl_value 
    11211121      LOGICAL                                        :: ll_sea 
     
    11241124      ! loop indices 
    11251125      INTEGER(i4) :: ji 
    1126       !----------------------------------------------------------------  
    1127   
     1126      !---------------------------------------------------------------- 
     1127 
    11281128      IF( td_bdy%l_use .AND. td_bdy%i_nseg == 1 )THEN 
    11291129 
     
    11371137 
    11381138               IF( ANY(dl_value(:) /= td_var%d_fill) )THEN 
    1139                    
     1139 
    11401140                  td_bdy%l_use=.TRUE. 
    11411141                  td_bdy%i_nseg=0 
     
    11661166 
    11671167               IF( ANY(dl_value(:) /= td_var%d_fill) )THEN 
    1168                    
     1168 
    11691169                  td_bdy%l_use=.TRUE. 
    11701170                  td_bdy%i_nseg=0 
     
    11911191         END SELECT 
    11921192      ENDIF 
    1193   
    1194    END SUBROUTINE boundary__get_seg_number  
     1193 
     1194   END SUBROUTINE boundary__get_seg_number 
    11951195   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    11961196   SUBROUTINE boundary__get_seg_indices(td_bdy, td_var, & 
    1197          &                              id_index, id_width, id_first, id_last)  
    1198    !-------------------------------------------------------------------  
     1197         &                              id_index, id_width, id_first, id_last) 
     1198   !------------------------------------------------------------------- 
    11991199   !> @brief This subroutine get segment indices for one boundary. 
    1200    !  
    1201    !> @details  
    1202    !  
    1203    !> @author J.Paul  
    1204    !> @date November, 2013 - Initial Version  
    1205    !  
    1206    !> @param[inout] td_bdy boundary structure   
    1207    !> @param[in] td_var    variable structure   
    1208    !> @param[in] id_index  boundary orthogonal index   
    1209    !> @param[in] id_width  bounary width  
     1200   ! 
     1201   !> @details 
     1202   ! 
     1203   !> @author J.Paul 
     1204   !> @date November, 2013 - Initial Version 
     1205   ! 
     1206   !> @param[inout] td_bdy boundary structure 
     1207   !> @param[in] td_var    variable structure 
     1208   !> @param[in] id_index  boundary orthogonal index 
     1209   !> @param[in] id_width  bounary width 
    12101210   !> @param[in] id_first  boundary first indice 
    12111211   !> @param[in] id_last   boundary last  indice 
    1212    !-------------------------------------------------------------------  
    1213  
    1214       IMPLICIT NONE  
     1212   !------------------------------------------------------------------- 
     1213 
     1214      IMPLICIT NONE 
    12151215 
    12161216      ! Argument 
     
    12221222      INTEGER(i4), INTENT(IN   ) :: id_last 
    12231223 
    1224       ! local variable  
     1224      ! local variable 
    12251225      INTEGER(i4)                                    :: il_nseg 
    12261226      INTEGER(i4), DIMENSION(ip_ncard)               :: il_max 
     
    12391239      INTEGER(i4) :: jk 
    12401240      INTEGER(i4) :: jl 
    1241       !----------------------------------------------------------------  
    1242   
     1241      !---------------------------------------------------------------- 
     1242 
    12431243      SELECT CASE(TRIM(td_bdy%c_card)) 
    12441244         CASE('north') 
    12451245            jk=jp_north 
    1246              
     1246 
    12471247            ALLOCATE( dl_value(td_var%t_dim(1)%i_len) ) 
    12481248            dl_value(:)=td_var%d_value(:,id_index,1,1) 
     
    12551255 
    12561256         CASE('east ') 
    1257             jk=jp_east  
     1257            jk=jp_east 
    12581258 
    12591259            ALLOCATE( dl_value(td_var%t_dim(2)%i_len) ) 
     
    12611261 
    12621262         CASE('west ') 
    1263             jk=jp_west  
     1263            jk=jp_west 
    12641264 
    12651265            ALLOCATE( dl_value(td_var%t_dim(2)%i_len) ) 
     
    12771277      il_min(jp_east )=1+ip_ghost 
    12781278      il_min(jp_west )=1+ip_ghost 
    1279           
    1280       ! special case for EW cyclic  
     1279 
     1280      ! special case for EW cyclic 
    12811281      IF( td_var%i_ew >= 0 )THEN 
    12821282         il_min(jp_north)=1 
     
    12861286         il_max(jp_south)=td_var%t_dim(1)%i_len 
    12871287      ENDIF 
    1288        
     1288 
    12891289      il_nseg=td_bdy%i_nseg 
    12901290      ! remove all segment from boundary 
     
    13331333               ll_sea=.FALSE. 
    13341334            ENDIF 
    1335              
     1335 
    13361336         ENDDO 
    13371337 
     
    13401340         ! clean 
    13411341         CALL seg__clean(tl_seg) 
    1342           
     1342 
    13431343      ENDDO 
    13441344 
    13451345      DEALLOCATE(dl_value) 
    1346        
    1347    END SUBROUTINE boundary__get_seg_indices  
     1346 
     1347   END SUBROUTINE boundary__get_seg_indices 
    13481348   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    13491349   SUBROUTINE boundary_check_corner(td_bdy, td_var) 
    1350    !-------------------------------------------------------------------  
    1351    !> @brief This subroutine check if there is boundary at corner, and  
    1352    !> adjust boundary indices if necessary.  
    1353    !  
    1354    !> @details  
     1350   !------------------------------------------------------------------- 
     1351   !> @brief This subroutine check if there is boundary at corner, and 
     1352   !> adjust boundary indices if necessary. 
     1353   ! 
     1354   !> @details 
    13551355   !> If there is a north west corner, first indices of north boundary 
    1356    !> should be the same as the west boundary indices.  
     1356   !> should be the same as the west boundary indices. 
    13571357   !> And the last indices of the west boundary should be the same as 
    13581358   !> the north indices. 
    13591359   !> More over the width of west and north boundary should be the same. 
    1360    !  
    1361    !> @author J.Paul  
    1362    !> @date November, 2013 - Initial Version  
    1363    !  
     1360   ! 
     1361   !> @author J.Paul 
     1362   !> @date November, 2013 - Initial Version 
     1363   ! 
    13641364   !> @param[inout] td_bdy boundary structure 
    13651365   !> @param[in] td_var    variable structure 
    1366    !-------------------------------------------------------------------  
    1367  
    1368       IMPLICIT NONE  
     1366   !------------------------------------------------------------------- 
     1367 
     1368      IMPLICIT NONE 
    13691369 
    13701370      ! Argument 
     
    13721372      TYPE(TVAR)                      , INTENT(IN   ) :: td_var 
    13731373 
    1374       ! local variable  
     1374      ! local variable 
    13751375      TYPE(TSEG)  :: tl_north 
    13761376      TYPE(TSEG)  :: tl_south 
    1377       TYPE(TSEG)  :: tl_east  
     1377      TYPE(TSEG)  :: tl_east 
    13781378      TYPE(TSEG)  :: tl_west 
    13791379 
     
    13811381 
    13821382      ! loop indices 
    1383       !----------------------------------------------------------------  
    1384   
     1383      !---------------------------------------------------------------- 
     1384 
    13851385      IF( .NOT. ASSOCIATED(td_var%d_value) )THEN 
    13861386         CALL logger_error("BOUNDARY CHEKC CORNER: no value associated "//& 
     
    14061406 
    14071407               il_width=MIN(tl_west%i_width,tl_north%i_width) 
    1408                 
     1408 
    14091409               tl_west%i_width =il_width 
    14101410               tl_north%i_width=il_width 
     
    14491449 
    14501450               il_width=MIN(tl_east%i_width,tl_north%i_width) 
    1451                 
     1451 
    14521452               tl_east%i_width =il_width 
    14531453               tl_north%i_width=il_width 
     
    14911491 
    14921492               il_width=MIN(tl_east%i_width,tl_south%i_width) 
    1493                 
     1493 
    14941494               tl_east%i_width =il_width 
    14951495               tl_south%i_width=il_width 
     
    15331533 
    15341534               il_width=MIN(tl_west%i_width,tl_south%i_width) 
    1535                 
     1535 
    15361536               tl_west%i_width =il_width 
    15371537               tl_south%i_width=il_width 
     
    15631563      CALL seg__clean(tl_west ) 
    15641564 
    1565    END SUBROUTINE boundary_check_corner  
    1566    !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    1567    SUBROUTINE boundary_check(td_bdy, td_var)  
    1568    !-------------------------------------------------------------------  
     1565   END SUBROUTINE boundary_check_corner 
     1566   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1567   SUBROUTINE boundary_check(td_bdy, td_var) 
     1568   !------------------------------------------------------------------- 
    15691569   !> @brief This subroutine check boundary. 
    1570    !  
    1571    !> @details  
     1570   ! 
     1571   !> @details 
    15721572   !> It checks that first and last indices as well as orthogonal index are 
    15731573   !> inside domain, and check corner (see boundary_check_corner). 
    1574    !  
    1575    !> @author J.Paul  
    1576    !> @date November, 2013 - Initial Version  
     1574   ! 
     1575   !> @author J.Paul 
     1576   !> @date November, 2013 - Initial Version 
    15771577   !> @date June, 2016 
    15781578   !> - Bug fix: take into account that boundaries are compute on T point, 
    15791579   !>   but expressed on U,V point 
    15801580   !> 
    1581    !> @param[inout] td_bdy boundary structure  
    1582    !> @param[in] td_var    variable structure  
    1583    !-------------------------------------------------------------------  
    1584  
    1585       IMPLICIT NONE  
     1581   !> @param[inout] td_bdy boundary structure 
     1582   !> @param[in] td_var    variable structure 
     1583   !------------------------------------------------------------------- 
     1584 
     1585      IMPLICIT NONE 
    15861586 
    15871587      ! Argument 
     
    15891589      TYPE(TVAR)                      , INTENT(IN   ) :: td_var 
    15901590 
    1591       ! local variable  
     1591      ! local variable 
    15921592      INTEGER(i4)      , DIMENSION(ip_ncard) :: il_max 
    15931593      INTEGER(i4)      , DIMENSION(ip_ncard) :: il_maxindex 
    15941594 
    1595       ! loop indices  
     1595      ! loop indices 
    15961596      INTEGER(i4) :: jk 
    1597       !----------------------------------------------------------------  
    1598   
     1597      !---------------------------------------------------------------- 
     1598 
    15991599      il_max(jp_north)=td_var%t_dim(1)%i_len 
    16001600      il_max(jp_south)=td_var%t_dim(1)%i_len 
    16011601      il_max(jp_east )=td_var%t_dim(2)%i_len 
    16021602      il_max(jp_west )=td_var%t_dim(2)%i_len 
    1603   
     1603 
    16041604      ! index expressed on U,V point, move on T point. 
    16051605      il_maxindex(jp_north)=td_var%t_dim(2)%i_len-ip_ghost+1 
     
    16371637         ENDIF 
    16381638      ENDDO 
    1639   
     1639 
    16401640      CALL boundary_check_corner(td_bdy, td_var) 
    16411641 
     
    16471647   ! 
    16481648   !> @detail 
    1649    !>  
     1649   !> 
    16501650   !> @author J.Paul 
    16511651   !> @date November, 2013 - Initial Version 
     
    16721672         CALL logger_error("BOUNDARY SWAP: no array of value "//& 
    16731673         &  "associted to variable "//TRIM(td_var%c_name) ) 
    1674       ELSE       
     1674      ELSE 
    16751675 
    16761676         SELECT CASE(TRIM(td_bdy%c_card)) 
     
    16881688            ENDDO 
    16891689 
    1690             DEALLOCATE( dl_value )          
     1690            DEALLOCATE( dl_value ) 
    16911691         CASE('east') 
    16921692            ALLOCATE( dl_value(td_var%t_dim(1)%i_len, & 
     
    17101710   END SUBROUTINE boundary_swap 
    17111711   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    1712    SUBROUTINE boundary__print_unit(td_bdy)  
    1713    !-------------------------------------------------------------------  
    1714    !> @brief This subroutine print information about one boundary.  
    1715    !  
    1716    !> @author J.Paul  
    1717    !> @date November, 2013 - Initial Version  
    1718    !  
    1719    !> @param[in] td_bdy boundary structure  
    1720    !-------------------------------------------------------------------  
    1721  
    1722       IMPLICIT NONE  
     1712   SUBROUTINE boundary__print_unit(td_bdy) 
     1713   !------------------------------------------------------------------- 
     1714   !> @brief This subroutine print information about one boundary. 
     1715   ! 
     1716   !> @author J.Paul 
     1717   !> @date November, 2013 - Initial Version 
     1718   ! 
     1719   !> @param[in] td_bdy boundary structure 
     1720   !------------------------------------------------------------------- 
     1721 
     1722      IMPLICIT NONE 
    17231723 
    17241724      ! Argument 
    17251725      TYPE(TBDY), INTENT(IN) :: td_bdy 
    17261726 
    1727       ! local variable  
    1728       ! loop indices  
     1727      ! local variable 
     1728      ! loop indices 
    17291729      INTEGER(i4) :: ji 
    1730       !----------------------------------------------------------------  
     1730      !---------------------------------------------------------------- 
    17311731 
    17321732      WRITE(*,'(a,/1x,a,/1x,a)') "Boundary "//TRIM(td_bdy%c_card), & 
     
    17401740         &  " last  "//TRIM(fct_str(td_bdy%t_seg(ji)%i_last)) 
    17411741      ENDDO 
    1742   
     1742 
    17431743   END SUBROUTINE boundary__print_unit 
    17441744   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    1745    SUBROUTINE boundary__print_arr(td_bdy)  
    1746    !-------------------------------------------------------------------  
    1747    !> @brief This subroutine print information about a array of boundary  
    1748    !  
    1749    !> @details  
    1750    !  
    1751    !> @author J.Paul  
    1752    !> @date November, 2013 - Initial Version  
    1753    !  
    1754    !> @param[in] td_bdy boundary structure  
    1755    !-------------------------------------------------------------------  
    1756  
    1757       IMPLICIT NONE  
     1745   SUBROUTINE boundary__print_arr(td_bdy) 
     1746   !------------------------------------------------------------------- 
     1747   !> @brief This subroutine print information about a array of boundary 
     1748   ! 
     1749   !> @details 
     1750   ! 
     1751   !> @author J.Paul 
     1752   !> @date November, 2013 - Initial Version 
     1753   ! 
     1754   !> @param[in] td_bdy boundary structure 
     1755   !------------------------------------------------------------------- 
     1756 
     1757      IMPLICIT NONE 
    17581758 
    17591759      ! Argument 
    17601760      TYPE(TBDY), DIMENSION(:), INTENT(IN) :: td_bdy 
    17611761 
    1762       ! local variable  
    1763       ! loop indices  
     1762      ! local variable 
     1763      ! loop indices 
    17641764      INTEGER(i4) :: ji 
    1765       !----------------------------------------------------------------  
     1765      !---------------------------------------------------------------- 
    17661766 
    17671767      DO ji=1,SIZE(td_bdy(:)) 
    17681768         CALL boundary_print(td_bdy(ji)) 
    17691769      ENDDO 
    1770   
     1770 
    17711771   END SUBROUTINE boundary__print_arr 
    17721772   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     
    17801780   !> structure (ex: tl_seg=seg__copy(seg__init()) is forbidden). 
    17811781   !> This will create memory leaks. 
    1782    !> @warning to avoid infinite loop, do not use any function inside  
     1782   !> @warning to avoid infinite loop, do not use any function inside 
    17831783   !> this subroutine 
    17841784   !> 
     
    17861786   !> @date November, 2013 - Initial Version 
    17871787   !> @date November, 2014 
    1788    !> - use function instead of overload assignment operator  
     1788   !> - use function instead of overload assignment operator 
    17891789   !> (to avoid memory leak) 
    17901790   ! 
     
    18091809      tf_seg%i_width    = td_seg%i_width 
    18101810      tf_seg%i_first    = td_seg%i_first 
    1811       tf_seg%i_last     = td_seg%i_last  
     1811      tf_seg%i_last     = td_seg%i_last 
    18121812 
    18131813   END FUNCTION seg__copy_unit 
     
    18211821   !> @warning do not use on the output of a function who create or read a 
    18221822   !> structure (ex: tl_seg=seg__copy(seg__init()) is forbidden). 
    1823    !> This will create memory leaks.    
    1824    !> @warning to avoid infinite loop, do not use any function inside  
     1823   !> This will create memory leaks. 
     1824   !> @warning to avoid infinite loop, do not use any function inside 
    18251825   !> this subroutine 
    18261826   !> 
     
    18281828   !> @date November, 2013 - Initial Version 
    18291829   !> @date November, 2014 
    1830    !> - use function instead of overload assignment operator  
     1830   !> - use function instead of overload assignment operator 
    18311831   !> (to avoid memory leak) 
    18321832   ! 
     
    18561856   FUNCTION seg__init(id_index, id_width, id_first, id_last) & 
    18571857         &  RESULT(tf_seg) 
    1858    !-------------------------------------------------------------------  
     1858   !------------------------------------------------------------------- 
    18591859   !> @brief This function  initialise segment structure. 
    1860    !  
    1861    !> @details  
     1860   ! 
     1861   !> @details 
    18621862   !> It simply add orthogonal index, and optionnaly width, first 
    1863    !> and last indices of the segment.  
    1864    !  
    1865    !> @author J.Paul  
    1866    !> @date November, 2013 - Initial Version  
    1867    !  
     1863   !> and last indices of the segment. 
     1864   ! 
     1865   !> @author J.Paul 
     1866   !> @date November, 2013 - Initial Version 
     1867   ! 
    18681868   !> @param[in] id_index  orthogonal index 
    1869    !> @param[in] id_width  width of the segment  
    1870    !> @param[in] id_first  first indices  
     1869   !> @param[in] id_width  width of the segment 
     1870   !> @param[in] id_first  first indices 
    18711871   !> @param[in] id_last   last  indices 
    18721872   !> @return segment structure 
    1873    !-------------------------------------------------------------------  
    1874  
    1875       IMPLICIT NONE  
     1873   !------------------------------------------------------------------- 
     1874 
     1875      IMPLICIT NONE 
    18761876 
    18771877      ! Argument 
     
    18791879      INTEGER(i4), INTENT(IN), OPTIONAL :: id_width 
    18801880      INTEGER(i4), INTENT(IN), OPTIONAL :: id_first 
    1881       INTEGER(i4), INTENT(IN), OPTIONAL :: id_last  
    1882  
    1883       ! function  
     1881      INTEGER(i4), INTENT(IN), OPTIONAL :: id_last 
     1882 
     1883      ! function 
    18841884      TYPE(TSEG)              :: tf_seg 
    18851885 
    1886       ! local variable  
    1887        
    1888       ! loop indices  
    1889       !----------------------------------------------------------------  
     1886      ! local variable 
     1887 
     1888      ! loop indices 
     1889      !---------------------------------------------------------------- 
    18901890 
    18911891      tf_seg%i_index=id_index 
     
    18951895      IF( PRESENT(id_last ) ) tf_seg%i_last =id_last 
    18961896 
    1897    END FUNCTION seg__init  
    1898    !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    1899    SUBROUTINE seg__clean_unit(td_seg)  
    1900    !-------------------------------------------------------------------  
    1901    !> @brief This subroutine clean segment structure.  
    1902    !  
    1903    !> @author J.Paul  
    1904    !> @date November, 2013 - Initial Version  
    1905    !  
     1897   END FUNCTION seg__init 
     1898   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     1899   SUBROUTINE seg__clean_unit(td_seg) 
     1900   !------------------------------------------------------------------- 
     1901   !> @brief This subroutine clean segment structure. 
     1902   ! 
     1903   !> @author J.Paul 
     1904   !> @date November, 2013 - Initial Version 
     1905   ! 
    19061906   !> @param[inout] td_seg segment structure 
    1907    !-------------------------------------------------------------------  
    1908  
    1909       IMPLICIT NONE  
    1910  
    1911       ! Argument        
     1907   !------------------------------------------------------------------- 
     1908 
     1909      IMPLICIT NONE 
     1910 
     1911      ! Argument 
    19121912      TYPE(TSEG), INTENT(INOUT) :: td_seg 
    19131913 
    1914       ! local variable  
     1914      ! local variable 
    19151915      TYPE(TSEG) :: tl_seg 
    1916       ! loop indices  
    1917       !----------------------------------------------------------------  
     1916      ! loop indices 
     1917      !---------------------------------------------------------------- 
    19181918 
    19191919      td_seg=seg__copy(tl_seg) 
    1920   
     1920 
    19211921   END SUBROUTINE seg__clean_unit 
    19221922   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    1923    SUBROUTINE seg__clean_arr(td_seg)  
    1924    !-------------------------------------------------------------------  
    1925    !> @brief This subroutine clean segment structure.  
    1926    !  
    1927    !> @author J.Paul  
    1928    !> @date November, 2013 - Initial Version  
    1929    !  
     1923   SUBROUTINE seg__clean_arr(td_seg) 
     1924   !------------------------------------------------------------------- 
     1925   !> @brief This subroutine clean segment structure. 
     1926   ! 
     1927   !> @author J.Paul 
     1928   !> @date November, 2013 - Initial Version 
     1929   ! 
    19301930   !> @param[inout] td_seg array of segment structure 
    1931    !-------------------------------------------------------------------  
    1932  
    1933       IMPLICIT NONE  
    1934  
    1935       ! Argument        
     1931   !------------------------------------------------------------------- 
     1932 
     1933      IMPLICIT NONE 
     1934 
     1935      ! Argument 
    19361936      TYPE(TSEG), DIMENSION(:), INTENT(INOUT) :: td_seg 
    19371937 
    1938       ! local variable  
    1939       ! loop indices  
     1938      ! local variable 
     1939      ! loop indices 
    19401940      INTEGER(i4) :: ji 
    1941       !----------------------------------------------------------------  
     1941      !---------------------------------------------------------------- 
    19421942 
    19431943      DO ji=SIZE(td_seg(:)),1,-1 
    19441944         CALL seg__clean(td_seg(ji)) 
    19451945      ENDDO 
    1946   
    1947    END SUBROUTINE seg__clean_arr  
     1946 
     1947   END SUBROUTINE seg__clean_arr 
    19481948   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    19491949END MODULE boundary 
  • utils/tools/SIREN/src/create_bathy.f90

    r12080 r13369  
    55! DESCRIPTION: 
    66!> @file 
    7 !> This program creates fine grid bathymetry file. 
     7!> This program creates target/fine grid bathymetry file. 
    88!> 
    99!> @section sec1 method 
    1010!> This bathymetry could be : 
    11 !> - extracted from a wider fine grid bathymetry file 
    12 !> - interpolated from a wider coarse grid bathymetry file 
     11!> - extracted from a wider target/fine grid bathymetry file 
     12!> - interpolated from a wider source/coarse grid bathymetry file 
    1313!> - handwritten 
    1414!> 
    15 !> @image html  bathy_40.png  
     15!> @image html  bathy_40.png 
    1616!> <center>@image latex bathy_30.png 
    1717!> </center> 
     
    4545!> 
    4646!>    here after, each sub-namelist parameters is detailed. 
    47 !>    @note  
     47!>    @note 
    4848!>       default values are specified between brackets 
    4949!> 
     
    6464!>          - none 
    6565!> 
    66 !>    - **in_maxerror** [@a 5]<br/>  
     66!>    - **in_maxerror** [@a 5]<br/> 
    6767!>       maximum number of error allowed 
    6868!> 
     
    7272!>    - **cn_varcfg** [@a ./cfg/variable.cfg]<br/> 
    7373!>       path to the variable configuration file.<br/> 
    74 !>       the variable configuration file defines standard name,  
    75 !>       default interpolation method, axis,...  
    76 !>       to be used for some known variables.<br/>  
    77 !> 
    78 !>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/>  
    79 !>       path to the dimension configuration file.<br/>  
    80 !>       the dimension configuration file defines dimensions allowed.<br/>  
    81 !> 
    82 !>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/>  
     74!>       the variable configuration file defines standard name, 
     75!>       default interpolation method, axis,... 
     76!>       to be used for some known variables.<br/> 
     77!> 
     78!>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/> 
     79!>       path to the dimension configuration file.<br/> 
     80!>       the dimension configuration file defines dimensions allowed.<br/> 
     81!> 
     82!>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/> 
    8383!>       path to the useless (dummy) configuration file.<br/> 
    84 !>       the dummy configuration file defines useless  
     84!>       the dummy configuration file defines useless 
    8585!>       dimension or variable. these dimension(s) or variable(s) will not be 
    8686!>       processed.<br/> 
    8787!> 
    88 !> @subsection subsrc namsrc  
     88!> @subsection subsrc namsrc 
    8989!>    the source/coarse grid sub-namelist parameters are : 
    9090!> 
    91 !>    - **cn_coord0** [@a ]<br/>  
     91!>    - **cn_coord0** [@a ]<br/> 
    9292!>       path to the coordinate file 
    9393!> 
    94 !>    - **in_perio0** [@a ]<br/>  
    95 !>       NEMO periodicity index<br/>  
     94!>    - **in_perio0** [@a ]<br/> 
     95!>       NEMO periodicity index<br/> 
    9696!>       the NEMO periodicity could be choose between 0 to 6: 
    9797!>       <dl> 
     
    115115!>       </dl> 
    116116!>       @sa For more information see @ref md_src_docsrc_6_perio 
    117 !>       and Model Boundary Condition paragraph in the  
     117!>       and Model Boundary Condition paragraph in the 
    118118!>       [NEMO documentation](https://forge.ipsl.jussieu.fr/nemo/chrome/site/doc/NEMO/manual/pdf/NEMO_manual.pdf) 
    119119!> 
    120 !> @subsection subtgt namtgt  
     120!> @subsection subtgt namtgt 
    121121!>    the target/fine grid sub-namelist parameters are : 
    122122!> 
    123 !>    - **cn_coord1** [@a ]<br/>  
     123!>    - **cn_coord1** [@a ]<br/> 
    124124!>       path to coordinate file 
    125125!> 
     
    133133!>       logical to fill closed sea or not 
    134134!> 
    135 !> @subsection subvar namvar  
     135!> @subsection subvar namvar 
    136136!>    the variable sub-namelist parameters are : 
    137137!> 
    138 !>    - **cn_varfile** [@a ]<br/>  
    139 !>       list of variable, and associated file  
    140 !>       @warning  
     138!>    - **cn_varfile** [@a ]<br/> 
     139!>       list of variable, and associated file 
     140!>       @warning 
    141141!>          variable name must be __Bathymetry__ here. 
    142142!> 
    143143!>       *cn_varfile* is the path and filename of the file where find 
    144144!>       variable. 
    145 !>       @note  
     145!>       @note 
    146146!>          *cn_varfile* could be a matrix of value, if you want to handwrite 
    147147!>          variable value.<br/> 
    148148!>          the variable array of value is split into equal subdomain.<br/> 
    149 !>          each subdomain is filled with the corresponding value  
    150 !>          of the matrix.<br/>           
     149!>          each subdomain is filled with the corresponding value 
     150!>          of the matrix.<br/> 
    151151!>          separators used to defined matrix are: 
    152152!>             - ',' for line 
     
    157157!>                                      1 & 4 & 5 \end{array} \right) @f$ 
    158158!> 
    159 !>       Examples:  
     159!>       Examples: 
    160160!>          - 'Bathymetry:gridT.nc' 
    161161!>          - 'Bathymetry:5000,5000,5000/5000,3000,5000/5000,5000,5000'<br/> 
    162162!> 
    163 !>       @note  
     163!>       @note 
    164164!>          Optionnaly, NEMO periodicity could be added following the filename. 
    165165!>          the periodicity must be separated by ';' 
     
    168168!>          - 'Bathymetry:gridT.nc ; perio=4'<br/> 
    169169!> 
    170 !>    - **cn_varinfo** [@a ]<br/>  
     170!>    - **cn_varinfo** [@a ]<br/> 
    171171!>       list of variable and extra information about request(s) to be used<br/> 
    172172!> 
    173173!>       each elements of *cn_varinfo* is a string character (separated by ',').<br/> 
    174 !>       it is composed of the variable name follow by ':',  
    175 !>       then request(s) to be used on this variable.<br/>  
     174!>       it is composed of the variable name follow by ':', 
     175!>       then request(s) to be used on this variable.<br/> 
    176176!>       request could be: 
    177177!>          - int = interpolation method 
     
    188188!>       informations about available method could be find in @ref interp, 
    189189!>       @ref extrap and @ref filter modules.<br/> 
    190 !>       Example:  
     190!>       Example: 
    191191!>          - 'Bathymetry: flt=2*hamming(2,3); min=0' 
    192192!> 
    193 !>       @note  
    194 !>          If you do not specify a method which is required,  
     193!>       @note 
     194!>          If you do not specify a method which is required, 
    195195!>          default one is apply. 
    196196!> 
    197 !>    - **ln_rand** [@a .False.]<br/>  
     197!>    - **ln_rand** [@a .False.]<br/> 
    198198!>          logical to add random value to Bathymetry<br/> 
    199 !>          Only for handmade Bathymetry.  
     199!>          Only for handmade Bathymetry. 
    200200!>          A random value (+/- 0.1% of the maximum depth) will 
    201201!>          will be added to avoid flat Bathymetry (which may cause issue). 
    202202!> 
    203 !> @subsection subnst namnst  
     203!> @subsection subnst namnst 
    204204!>    the nesting sub-namelist parameters are : 
    205205!> 
    206 !>    - **in_rhoi**  [@a 1]<br/>  
     206!>    - **in_rhoi**  [@a 1]<br/> 
    207207!>       refinement factor in i-direction 
    208208!> 
    209 !>    - **in_rhoj**  [@a 1]<br/>  
     209!>    - **in_rhoj**  [@a 1]<br/> 
    210210!>       refinement factor in j-direction 
    211211!> 
    212 !>    @note  
    213 !>       coarse grid indices will be deduced from fine grid 
     212!>    @note 
     213!>       source/coarse grid indices will be deduced from target/fine grid 
    214214!>       coordinate file. 
    215215!> 
    216 !> @subsection subout namout  
     216!> @subsection subout namout 
    217217!>    the output sub-namelist parameter is : 
    218218!> 
     
    224224!> 
    225225!> @date November, 2013 - Initial Version 
    226 !> @date Sepember, 2014  
     226!> @date Sepember, 2014 
    227227!> - add header for user 
    228228!> - Bug fix, compute offset depending of grid point 
     
    317317 
    318318   TYPE(TATT)                                         :: tl_att 
    319     
     319 
    320320   TYPE(TVAR)                                         :: tl_lon 
    321321   TYPE(TVAR)                                         :: tl_lat 
     
    325325   TYPE(TVAR)                                         :: tl_tmp 
    326326   TYPE(TVAR)       , DIMENSION(:), ALLOCATABLE       :: tl_var 
    327     
     327 
    328328   TYPE(TDIM)       , DIMENSION(ip_maxdim)            :: tl_dim 
    329329 
     
    341341   ! namelist variable 
    342342   ! namlog 
    343    CHARACTER(LEN=lc)                       :: cn_logfile    = 'create_bathy.log'  
    344    CHARACTER(LEN=lc)                       :: cn_verbosity  = 'warning'  
     343   CHARACTER(LEN=lc)                       :: cn_logfile    = 'create_bathy.log' 
     344   CHARACTER(LEN=lc)                       :: cn_verbosity  = 'warning' 
    345345   INTEGER(i4)                             :: in_maxerror   = 5 
    346346 
    347347   ! namcfg 
    348    CHARACTER(LEN=lc)                       :: cn_varcfg  = './cfg/variable.cfg'  
     348   CHARACTER(LEN=lc)                       :: cn_varcfg  = './cfg/variable.cfg' 
    349349   CHARACTER(LEN=lc)                       :: cn_dimcfg  = './cfg/dimension.cfg' 
    350350   CHARACTER(LEN=lc)                       :: cn_dumcfg  = './cfg/dummy.cfg' 
    351351 
    352352   ! namsrc 
    353    CHARACTER(LEN=lc)                       :: cn_coord0  = ''  
     353   CHARACTER(LEN=lc)                       :: cn_coord0  = '' 
    354354   INTEGER(i4)                             :: in_perio0  = -1 
    355355 
     
    369369 
    370370   ! namout 
    371    CHARACTER(LEN=lc)                       :: cn_fileout = 'bathy_fine.nc'  
     371   CHARACTER(LEN=lc)                       :: cn_fileout = 'bathy_fine.nc' 
    372372   !------------------------------------------------------------------- 
    373373 
     
    390390   &  in_perio1,     &  !< periodicity index 
    391391   &  ln_fillclosed     !< fill closed sea 
    392   
     392 
    393393   NAMELIST /namvar/ &  !< variable namelist 
    394394   &  cn_varfile,    &  !< list of variable file 
    395395   &  cn_varinfo,    &  !< list of variable and interpolation method to be used. (ex: 'votemper:linear','vosaline:cubic' ) 
    396396   &  ln_rand           !< add random value to avoid flat bathymetry 
    397   
     397 
    398398   NAMELIST /namnst/ &  !< nesting namelist 
    399399   &  in_rhoi,       &  !< refinement factor in i-direction 
     
    401401 
    402402   NAMELIST /namout/ &  !< output namelist 
    403    &  cn_fileout        !< fine grid bathymetry file 
     403   &  cn_fileout        !< target/fine grid bathymetry file 
    404404   !------------------------------------------------------------------- 
    405405 
     
    414414   IF( il_narg /= 1 )THEN 
    415415      WRITE(cl_errormsg,*) ' ERROR : one argument is needed ' 
    416       CALL fct_help(cp_myname,cl_errormsg)  
     416      CALL fct_help(cp_myname,cl_errormsg) 
    417417      CALL EXIT(1) 
    418418   ELSE 
     
    449449               IF( il_status /= 0 )THEN 
    450450                  WRITE(cl_errormsg,*) " ERROR : error opening "//TRIM(cl_namelist) 
    451                   CALL fct_help(cp_myname,cl_errormsg)  
     451                  CALL fct_help(cp_myname,cl_errormsg) 
    452452                  CALL EXIT(1) 
    453453               ENDIF 
    454454 
    455455               READ( il_fileid, NML = namlog ) 
    456   
     456 
    457457               ! define logger file 
    458458               CALL logger_open(TRIM(cn_logfile),TRIM(cn_verbosity),in_maxerror) 
     
    493493 
    494494               WRITE(cl_errormsg,*) " ERROR : can't find "//TRIM(cl_namelist) 
    495                CALL fct_help(cp_myname,cl_errormsg)  
     495               CALL fct_help(cp_myname,cl_errormsg) 
    496496               CALL EXIT(1) 
    497497 
     
    511511      CALL grid_get_info(tl_coord0) 
    512512   ELSE 
    513       CALL logger_fatal("CREATE BATHY: no coarse grid coordinate found. "//& 
    514       &     "check namelist")       
     513      CALL logger_fatal("CREATE BATHY: no source/coarse grid coordinate found. "//& 
     514      &     "check namelist") 
    515515   ENDIF 
    516516 
     
    522522      CALL grid_get_info(tl_coord1) 
    523523   ELSE 
    524       CALL logger_fatal("CREATE BATHY: no fine grid coordinate found. "//& 
     524      CALL logger_fatal("CREATE BATHY: no target/fine grid coordinate found. "//& 
    525525      &     "check namelist") 
    526526   ENDIF 
     
    550550 
    551551   ! check domain indices 
    552    ! compute coarse grid indices around fine grid 
     552   ! compute source/coarse grid indices around target/fine grid 
    553553   il_ind(:,:)=grid_get_coarse_index( tl_coord0, tl_coord1, & 
    554554   &                                  id_rho=il_rho(:) ) 
     
    560560   CALL grid_check_dom(tl_coord0, il_imin0, il_imax0, il_jmin0, il_jmax0) 
    561561 
    562    ! check coincidence between coarse and fine grid 
     562   ! check coincidence between coarse and target/fine grid 
    563563   CALL grid_check_coincidence( tl_coord0, tl_coord1, & 
    564564   &                            il_imin0, il_imax0, & 
     
    574574      jk=0 
    575575      DO ji=1,tl_multi%i_nmpp 
    576        
     576 
    577577         WRITE(cl_data,'(a,i2.2)') 'data-',jk+1 
    578578         IF( .NOT. ASSOCIATED(tl_multi%t_mpp(ji)%t_proc(1)%t_var) )THEN 
     
    622622            IF( ANY(tl_mpp%t_dim(1:2)%i_len /= tl_coord0%t_dim(1:2)%i_len).OR.& 
    623623            &   ALL(il_rho(:)==1) )THEN 
    624                !- extract bathymetry from fine grid bathymetry  
     624               !- extract bathymetry from target/fine grid bathymetry 
    625625               DO jj=1,tl_multi%t_mpp(ji)%t_proc(1)%i_nvar 
    626626                  jk=jk+1 
    627627                  tl_tmp=var_copy(tl_multi%t_mpp(ji)%t_proc(1)%t_var(jj)) 
    628   
     628 
    629629                  tl_var(jk)=create_bathy_extract( tl_tmp, tl_mpp, & 
    630630                  &                                tl_coord1 ) 
     
    633633               CALL var_clean(tl_tmp) 
    634634            ELSE 
    635                !- get bathymetry from coarse grid bathymetry  
     635               !- get bathymetry from source/coarse grid bathymetry 
    636636               DO jj=1,tl_multi%t_mpp(ji)%t_proc(1)%i_nvar 
    637637                  jk=jk+1 
     
    792792      CALL file_add_att(tl_fileout,tl_att) 
    793793   ENDIF 
    794     
     794 
    795795   ! create file 
    796796   CALL iom_create(tl_fileout) 
     
    821821   !> @brief 
    822822   !> This function create variable, filled with matrix value 
    823    !>  
    824    !> @details  
    825    !> A variable is create with the same name that the input variable,  
    826    !> and with dimension of the coordinate file.<br/>  
     823   !> 
     824   !> @details 
     825   !> A variable is create with the same name that the input variable, 
     826   !> and with dimension of the coordinate file.<br/> 
    827827   !> Then the variable array of value is split into equal subdomain. 
    828828   !> Each subdomain is filled with the corresponding value of the matrix. 
     
    834834   !> @date November, 2013 - Initial Version 
    835835   !> 
    836    !> @param[in] td_var    variable structure  
     836   !> @param[in] td_var    variable structure 
    837837   !> @param[in] td_coord  coordinate file structure 
    838838   !> @param[in] ld_rand   add random value to bathymetry 
     
    903903      CALL var_clean(tl_lon) 
    904904 
    905       ! split output domain in N subdomain depending of matrix dimension  
     905      ! split output domain in N subdomain depending of matrix dimension 
    906906      il_size(:) = tl_dim(1:2)%i_len / il_dim(:) 
    907907      il_rest(:) = MOD(tl_dim(1:2)%i_len, il_dim(:)) 
     
    923923      il_jshape(il_dim(2)+1)=il_jshape(il_dim(2)+1)+il_rest(2) 
    924924 
    925       ! write ouput array of value  
     925      ! write ouput array of value 
    926926      ALLOCATE(dl_value( tl_dim(1)%i_len, & 
    927927      &                  tl_dim(2)%i_len, & 
     
    932932      DO jj=2,il_dim(2)+1 
    933933         DO ji=2,il_dim(1)+1 
    934              
     934 
    935935            dl_value( 1+il_ishape(ji-1):il_ishape(ji), & 
    936936            &         1+il_jshape(jj-1):il_jshape(jj), & 
     
    944944         ALLOCATE(dl_ran(tl_dim(1)%i_len, & 
    945945         &               tl_dim(2)%i_len) ) 
    946        
     946 
    947947         ! set random value between 0 and 1 
    948948         CALL RANDOM_NUMBER(dl_ran(:,:)) 
     
    953953 
    954954         dl_value(:,:,1,1)=dl_value(:,:,1,1)+dl_ran(:,:) 
    955        
     955 
    956956         DEALLOCATE(dl_ran) 
    957957      ENDIF 
     
    976976   !> This function extract variable from file over coordinate domain and 
    977977   !> return variable structure 
    978    !>  
     978   !> 
    979979   !> @author J.Paul 
    980980   !> @date November, 2013 - Initial Version 
    981981   !> 
    982    !> @param[in] td_var    variable structure  
     982   !> @param[in] td_var    variable structure 
    983983   !> @param[in] td_mpp    mpp file structure 
    984984   !> @param[in] td_coord  coordinate file structure 
     
    989989 
    990990      ! Argument 
    991       TYPE(TVAR), INTENT(IN) :: td_var   
     991      TYPE(TVAR), INTENT(IN) :: td_var 
    992992      TYPE(TMPP), INTENT(IN) :: td_mpp 
    993993      TYPE(TMPP), INTENT(IN) :: td_coord 
     
    10711071         ! add attribute to variable 
    10721072         tl_att=att_init('src_file',TRIM(fct_basename(tl_mpp%c_name))) 
    1073          CALL var_move_att(tf_var, tl_att)          
     1073         CALL var_move_att(tf_var, tl_att) 
    10741074 
    10751075         tl_att=att_init('src_i_indices',(/tl_dom%i_imin, tl_dom%i_imax/)) 
     
    10941094   !------------------------------------------------------------------- 
    10951095   !> @brief 
    1096    !> This function get coarse grid variable, interpolate variable, and return 
    1097    !> variable structure over fine grid 
    1098    !>  
     1096   !> This function get source/coarse grid variable, interpolate variable, and return 
     1097   !> variable structure over target/fine grid 
     1098   !> 
    10991099   !> @author J.Paul 
    11001100   !> @date November, 2013 - Initial Version 
     
    11021102   !> @param[in] td_var    variable structure 
    11031103   !> @param[in] td_mpp    mpp file structure 
    1104    !> @param[in] id_imin   i-direction lower left  corner indice  
    1105    !> @param[in] id_imax   i-direction upper right corner indice  
     1104   !> @param[in] id_imin   i-direction lower left  corner indice 
     1105   !> @param[in] id_imax   i-direction upper right corner indice 
    11061106   !> @param[in] id_jmin   j-direction lower left  corner indice 
    1107    !> @param[in] id_jmax   j-direction upper right corner indice  
    1108    !> @param[in] id_offset offset between fine grid and coarse grid 
     1107   !> @param[in] id_jmax   j-direction upper right corner indice 
     1108   !> @param[in] id_offset offset between target/fine grid and source/coarse grid 
    11091109   !> @param[in] id_rho    array of refinement factor 
    11101110   !> @return variable structure 
     
    11141114 
    11151115      ! Argument 
    1116       TYPE(TVAR)                 , INTENT(IN) :: td_var   
    1117       TYPE(TMPP)                 , INTENT(IN) :: td_mpp  
     1116      TYPE(TVAR)                 , INTENT(IN) :: td_var 
     1117      TYPE(TMPP)                 , INTENT(IN) :: td_mpp 
    11181118      INTEGER(i4)                , INTENT(IN) :: id_imin 
    11191119      INTEGER(i4)                , INTENT(IN) :: id_imax 
     
    11641164      ALLOCATE( il_rho(il_size) ) 
    11651165      il_rho(:)=id_rho(:) 
    1166        
     1166 
    11671167      !- interpolate variable 
    11681168      CALL create_bathy_interp(tf_var, il_rho(:), id_offset(:,:)) 
     
    11751175      !- add ghost cell 
    11761176      CALL grid_add_ghost(tf_var,tl_dom%i_ghost(:,:)) 
    1177   
     1177 
    11781178      !- add attribute to variable 
    11791179      tl_att=att_init('src_file',TRIM(fct_basename(tl_mpp%c_name))) 
     
    11961196      CALL att_clean(tl_att) 
    11971197      CALL mpp_clean(tl_mpp) 
    1198   
     1198 
    11991199   END FUNCTION create_bathy_get_var 
    12001200   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     
    12041204   !> @brief 
    12051205   !> This subroutine interpolate variable 
    1206    !>  
     1206   !> 
    12071207   !> @author J.Paul 
    12081208   !> @date November, 2013 - Initial Version 
    12091209   !> 
    1210    !> @param[inout] td_var variable structure  
     1210   !> @param[inout] td_var variable structure 
    12111211   !> @param[in] id_rho    array of refinment factor 
    1212    !> @param[in] id_offset array of offset between fine and coarse grid 
     1212   !> @param[in] id_offset array of offset between target/fine and source/coarse grid 
    12131213   !> @param[in] id_iext   i-direction size of extra bands (default=im_minext) 
    12141214   !> @param[in] id_jext   j-direction size of extra bands (default=im_minext) 
     
    12621262 
    12631263      bl_mask(:,:,:,:)=1 
    1264       WHERE(td_var%d_value(:,:,:,:)==td_var%d_fill) bl_mask(:,:,:,:)=0       
     1264      WHERE(td_var%d_value(:,:,:,:)==td_var%d_fill) bl_mask(:,:,:,:)=0 
    12651265 
    12661266      SELECT CASE(TRIM(td_var%c_point)) 
     
    12951295      CALL extrap_del_extrabands(td_var, il_iext*id_rho(jp_I), il_jext*id_rho(jp_J)) 
    12961296 
    1297       ! keep original mask  
     1297      ! keep original mask 
    12981298      WHERE( tl_mask%d_value(:,:,:,:) == 0 ) 
    12991299         td_var%d_value(:,:,:,:)=td_var%d_fill 
     
    13101310   !> This subroutine get depth variable value in an open mpp structure 
    13111311   !> and check if agree with already input depth variable. 
    1312    !>  
    1313    !> @details  
     1312   !> 
     1313   !> @details 
    13141314   !> 
    13151315   !> @author J.Paul 
     
    13171317   !> 
    13181318   !> @param[in] td_mpp       mpp structure 
    1319    !> @param[inout] td_depth  depth variable structure  
     1319   !> @param[inout] td_depth  depth variable structure 
    13201320   !------------------------------------------------------------------- 
    13211321 
     
    13551355 
    13561356      ENDIF 
    1357        
     1357 
    13581358   END SUBROUTINE create_bathy_check_depth 
    13591359   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     
    13631363   !> This subroutine get date and time in an open mpp structure 
    13641364   !> and check if agree with date and time already read. 
    1365    !>  
    1366    !> @details  
     1365   !> 
     1366   !> @details 
    13671367   !> 
    13681368   !> @author J.Paul 
     
    13701370   !> 
    13711371   !> @param[in] td_mpp      mpp structure 
    1372    !> @param[inout] td_time  time variable structure  
     1372   !> @param[inout] td_time  time variable structure 
    13731373   !------------------------------------------------------------------- 
    13741374 
     
    14121412 
    14131413      ENDIF 
    1414        
     1414 
    14151415   END SUBROUTINE create_bathy_check_time 
    14161416   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
  • utils/tools/SIREN/src/create_boundary.F90

    r12267 r13369  
    55! DESCRIPTION: 
    66!> @file 
    7 !> @brief  
     7!> @brief 
    88!> This program creates boundary files. 
    99!> 
    1010!> @details 
    1111!> @section sec1 method 
    12 !> Variables are read from coarse grid standard output,  
    13 !> extracted or interpolated on fine grid.  
     12!> Variables are read from source/coarse grid standard output, 
     13!> extracted or interpolated on target/fine grid. 
    1414!> Variables could also be manually written.<br/> 
    15 !> @note  
     15!> @note 
    1616!>    method could be different for each variable. 
    1717!> 
    18 !>  <br/>  
    19 !> @image html  boundary_NEATL36_70.png  
     18!>  <br/> 
     19!> @image html  boundary_NEATL36_70.png 
    2020!> <center>@image latex boundary_NEATL36_70.png 
    2121!> </center> 
     
    3737!>       - -v, --version<br/> 
    3838!>          show Siren's version   (and exit)<br/> 
    39 !>    @note  
     39!>    @note 
    4040!>       compiled with @a key_mpp_mpi, could be run on multi processor :<br/> 
    4141!>       USAGE: create_boundary create_bounary.nam create_bounary2.nam ... [-v] [-h]<br/> 
     
    5454!> 
    5555!>    here after, each sub-namelist parameters is detailed. 
    56 !>    @note  
     56!>    @note 
    5757!>       default values are specified between brackets 
    5858!> 
     
    7373!>          - none 
    7474!> 
    75 !>    - **in_maxerror** [@a 5]<br/>  
     75!>    - **in_maxerror** [@a 5]<br/> 
    7676!>       maximum number of error allowed 
    7777!> 
     
    8181!>    - **cn_varcfg** [@a ./cfg/variable.cfg]<br/> 
    8282!>       path to the variable configuration file.<br/> 
    83 !>       the variable configuration file defines standard name,  
    84 !>       default interpolation method, axis,...  
    85 !>       to be used for some known variables.<br/>  
    86 !> 
    87 !>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/>  
    88 !>       path to the dimension configuration file.<br/>  
    89 !>       the dimension configuration file defines dimensions allowed.<br/>  
    90 !> 
    91 !>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/>  
     83!>       the variable configuration file defines standard name, 
     84!>       default interpolation method, axis,... 
     85!>       to be used for some known variables.<br/> 
     86!> 
     87!>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/> 
     88!>       path to the dimension configuration file.<br/> 
     89!>       the dimension configuration file defines dimensions allowed.<br/> 
     90!> 
     91!>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/> 
    9292!>       path to the useless (dummy) configuration file.<br/> 
    93 !>       the dummy configuration file defines useless  
     93!>       the dummy configuration file defines useless 
    9494!>       dimension or variable. these dimension(s) or variable(s) will not be 
    9595!>       processed.<br/> 
    9696!> 
    97 !> @subsection subcrs namcrs  
    98 !>    the coarse grid sub-namelist parameters are : 
    99 !> 
    100 !>    - **cn_coord0** [@a ]<br/>  
     97!> @subsection subcrs namcrs 
     98!>    the source/coarse grid sub-namelist parameters are : 
     99!> 
     100!>    - **cn_coord0** [@a ]<br/> 
    101101!>       path to the coordinate file 
    102102!> 
    103 !>    - **in_perio0** [@a ]<br/>  
    104 !>       NEMO periodicity index<br/>  
     103!>    - **in_perio0** [@a ]<br/> 
     104!>       NEMO periodicity index<br/> 
    105105!>       the NEMO periodicity could be choose between 0 to 6: 
    106106!>       <dl> 
     
    124124!>       </dl> 
    125125!>       @sa For more information see @ref md_src_docsrc_6_perio 
    126 !>       and Model Boundary Condition paragraph in the  
     126!>       and Model Boundary Condition paragraph in the 
    127127!>       [NEMO documentation](https://forge.ipsl.jussieu.fr/nemo/chrome/site/doc/NEMO/manual/pdf/NEMO_manual.pdf) 
    128128!> 
    129 !> @subsection subfin namfin  
    130 !>    the fine grid sub-namelist parameters are : 
    131 !> 
    132 !>    - **cn_coord1** [@a ]<br/>  
     129!> @subsection subfin namfin 
     130!>    the target/fine grid sub-namelist parameters are : 
     131!> 
     132!>    - **cn_coord1** [@a ]<br/> 
    133133!>       path to coordinate file 
    134134!> 
    135 !>    - **cn_bathy1** [@a ]<br/>  
     135!>    - **cn_bathy1** [@a ]<br/> 
    136136!>       path to bathymetry file 
    137 !>       @warning  
     137!>       @warning 
    138138!> 
    139139!>    - **in_perio1** [@a ]<br/> 
     
    181181!>       number of vertical level 
    182182!> 
    183 !>     @note  
     183!>     @note 
    184184!>       If *dn_ppa1*, *dn_ppa0* and *dn_ppsur* are undefined, 
    185185!>       NEMO will compute them from *dn_ppdzmin, dn_pphmax, dn_ppkth, dn_ppacr* 
     
    193193!>       minimum thickness ratio of partial step level 
    194194!> 
    195 !> @subsection subvar namvar  
     195!> @subsection subvar namvar 
    196196!>    the variable sub-namelist parameters are : 
    197197!> 
    198 !>    - **cn_varfile** [@a ]<br/>  
    199 !>       list of variable, and associated file  
     198!>    - **cn_varfile** [@a ]<br/> 
     199!>       list of variable, and associated file 
    200200!> 
    201201!>       *cn_varfile* is the path and filename of the file where find 
    202202!>       variable. 
    203 !>       @note  
     203!>       @note 
    204204!>          *cn_varfile* could be a matrix of value, if you want to handwrite 
    205205!>          variable value.<br/> 
    206206!>          the variable array of value is split into equal subdomain.<br/> 
    207 !>          each subdomain is filled with the corresponding value  
    208 !>          of the matrix.<br/>           
     207!>          each subdomain is filled with the corresponding value 
     208!>          of the matrix.<br/> 
    209209!>          separators used to defined matrix are: 
    210210!>             - ',' for line 
     
    216216!>                                      1 & 4 & 5 \end{array} \right) @f$ 
    217217!> 
    218 !>          @warning  
     218!>          @warning 
    219219!>             the same matrix is used for all boundaries. 
    220220!> 
    221 !>       Examples:  
     221!>       Examples: 
    222222!>          - 'votemper:gridT.nc', 'vozocrtx:gridU.nc' 
    223223!>          - 'votemper:10\25', 'vozocrtx:gridU.nc'<br/> 
    224224!> 
    225 !>       @note  
     225!>       @note 
    226226!>          Optionnaly, NEMO periodicity could be added following the filename. 
    227227!>          the periodicity must be separated by ';' 
     
    230230!>          - 'votemper:gridT.nc ; perio=4' 
    231231!> 
    232 !>    - **cn_varinfo** [@a ]<br/>  
     232!>    - **cn_varinfo** [@a ]<br/> 
    233233!>       list of variable and extra information about request(s) to be used<br/> 
    234234!> 
    235235!>       each elements of *cn_varinfo* is a string character (separated by ',').<br/> 
    236 !>       it is composed of the variable name follow by ':',  
    237 !>       then request(s) to be used on this variable.<br/>  
     236!>       it is composed of the variable name follow by ':', 
     237!>       then request(s) to be used on this variable.<br/> 
    238238!>       request could be: 
    239239!>          - int = interpolation method 
     
    250250!>       informations about available method could be find in @ref interp, 
    251251!>       @ref extrap and @ref filter modules.<br/> 
    252 !>       Example:  
     252!>       Example: 
    253253!>          - 'votemper: int=linear; flt=hann; ext=dist_weight', 
    254254!>            'vosaline: int=cubic' 
    255255!> 
    256 !>       @note  
    257 !>          If you do not specify a method which is required,  
     256!>       @note 
     257!>          If you do not specify a method which is required, 
    258258!>          default one is apply. 
    259259!> 
    260 !> @subsection subnst namnst  
     260!> @subsection subnst namnst 
    261261!>    the nesting sub-namelist parameters are : 
    262262!> 
    263 !>    - **in_rhoi**  [@a 1]<br/>  
     263!>    - **in_rhoi**  [@a 1]<br/> 
    264264!>       refinement factor in i-direction 
    265265!> 
    266 !>    - **in_rhoj**  [@a 1]<br/>  
     266!>    - **in_rhoj**  [@a 1]<br/> 
    267267!>       refinement factor in j-direction 
    268268!> 
    269 !>    @note  
    270 !>       coarse grid indices will be deduced from fine grid 
     269!>    @note 
     270!>       source/coarse grid indices will be deduced from target/fine grid 
    271271!>       coordinate file. 
    272272!> 
     
    274274!>    the boundary sub-namelist parameters are : 
    275275!> 
    276 !>    - **ln_north** [@a .TRUE.]<br/>  
     276!>    - **ln_north** [@a .TRUE.]<br/> 
    277277!>       logical to use north boundary or not 
    278278!>    - **ln_south** [@a .TRUE.]<br/> 
     
    284284!>    <br/> <br/> 
    285285!>    - **cn_north** [@a ]<br/> 
    286 !>       north boundary indices on fine grid<br/> 
     286!>       north boundary indices on target/fine grid<br/> 
    287287!>    - **cn_south** [@a ]<br/> 
    288 !>       south boundary indices on fine grid<br/> 
     288!>       south boundary indices on target/fine grid<br/> 
    289289!>    - **cn_east**  [@a ]<br/> 
    290 !>       east  boundary indices on fine grid<br/> 
     290!>       east  boundary indices on target/fine grid<br/> 
    291291!>    - **cn_west**  [@a ]<br/> 
    292 !>       west  boundary indices on fine grid<br/> 
     292!>       west  boundary indices on target/fine grid<br/> 
    293293!> 
    294294!>       *cn_north* is a string character defining boundary 
     
    296296!>       segments are separated by '|'.<br/> 
    297297!>       each segments of the boundary is composed of: 
    298 !>          - indice of velocity (orthogonal to boundary .ie.  
    299 !>             for north boundary, J-indice).  
    300 !>          - indice of segment start (I-indice for north boundary)  
     298!>          - indice of velocity (orthogonal to boundary .ie. 
     299!>             for north boundary, J-indice). 
     300!>          - indice of segment start (I-indice for north boundary) 
    301301!>          - indice of segment end   (I-indice for north boundary)<br/> 
    302302!>             indices must be separated by ':' .<br/> 
    303 !>          - optionally, boundary size could be added between '(' and ')'  
     303!>          - optionally, boundary size could be added between '(' and ')' 
    304304!>          in the first segment defined. 
    305 !>             @note  
     305!>             @note 
    306306!>                boundary size is the same for all segments of one boundary. 
    307307!> 
     
    310310!>          - cn_north='index1(width),first1:last1|index2,first2:last2' 
    311311!> 
    312 !>       @image html  boundary_50.png  
     312!>       @image html  boundary_50.png 
    313313!>       <center>@image latex boundary_50.png 
    314314!>       </center> 
     
    318318!> 
    319319!>    @note 
    320 !>       the number of point(s) with coarse value save at boundaries is 
     320!>       the number of point(s) with source/coarse value save at boundaries is 
    321321!>       defined with the *weight* variable (see @ref merge_bathy) 
    322322!> 
    323 !> @subsection subout namout  
     323!> @subsection subout namout 
    324324!>    the output sub-namelist parameter is : 
    325325!> 
     
    336336!>       date offset in day (change only ouput file name) 
    337337!> 
    338 !>       Examples:  
     338!>       Examples: 
    339339!>          - cn_fileout='boundary.nc'<br/> 
    340 !>             if time_counter (16/07/2015 00h) is read on input file (see varfile),  
     340!>             if time_counter (16/07/2015 00h) is read on input file (see varfile), 
    341341!>             west boundary will be named boundary_west_y2015m07d16 
    342342!>          - dn_dayofs=-2.<br/> 
     
    356356!>       @note 
    357357!>          we have to fill most of the parameters with as many elements as there are open boundaries 
    358 !>  
     358!> 
    359359!>       Regarding the width of the relaxation zone **nn_rimwidth**, 
    360 !>       this information is available as a global attribute (**bdy_width**)  
    361 !>       in the metadata of boundary files created with SIREN  
     360!>       this information is available as a global attribute (**bdy_width**) 
     361!>       in the metadata of boundary files created with SIREN 
    362362!> 
    363363!> @code{.sh} 
     
    365365!> @endcode 
    366366!>       @warning 
    367 !>          The order of the boundaries must stay unchanged, in parameters list as well as  
    368 !>          in the next sub-namelsits  
     367!>          The order of the boundaries must stay unchanged, in parameters list as well as 
     368!>          in the next sub-namelsits 
    369369!> 
    370370!>    Example:<br/> 
     
    385385!>                                         !  = 2, use tidal harmonic forcing data from files 
    386386!>                                         !  = 3, use external data AND tidal harmonic forcing 
    387 !>   cn_dyn3d       = 'specified','specified' !   
     387!>   cn_dyn3d       = 'specified','specified' ! 
    388388!>   nn_dyn3d_dta   = 1,1                  !  = 0, bdy data are equal to the initial state 
    389389!>                                         !  = 1, bdy data are read in 'bdydata   .nc' files 
    390 !>   cn_tra         = 'specified','specified' !  
     390!>   cn_tra         = 'specified','specified' ! 
    391391!>   nn_tra_dta     = 1,1                  !  = 0, bdy data are equal to the initial state 
    392392!>                                         !  = 1, bdy data are read in 'bdydata   .nc' files 
     
    394394!>   ln_tra_dmp    =.true.,.true.          !  open boudaries conditions for tracers 
    395395!>   ln_dyn3d_dmp  =.true.,.true.          !  open boundary condition for baroclinic velocities 
    396 !>   rn_time_dmp     =  1.,1.              ! Damping time scale in days  
     396!>   rn_time_dmp     =  1.,1.              ! Damping time scale in days 
    397397!>   rn_time_dmp_out =  1.,1.              ! Outflow damping time scale 
    398398!>   nn_rimwidth   = 10,10                 !  width of the relaxation zone 
     
    413413!>          as well as indice of velocity row or column (**nbdyind**).<br/> 
    414414!> 
    415 !>          Those informations are available as global attributes  
    416 !>          (respectively **bdy_deb, bdy_end, bdy_ind**) in the metadata of our boundary files  
     415!>          Those informations are available as global attributes 
     416!>          (respectively **bdy_deb, bdy_end, bdy_ind**) in the metadata of our boundary files 
    417417!>          created with SIREN. 
    418418!> 
     
    589589   IF( il_narg /= 1 )THEN 
    590590      WRITE(cl_errormsg,*) ' ERROR : one argument is needed ' 
    591       CALL fct_help(cp_myname,cl_errormsg)  
     591      CALL fct_help(cp_myname,cl_errormsg) 
    592592      CALL EXIT(1) 
    593593   ELSE 
     
    608608 
    609609            cl_namelist=cl_arg 
    610              
     610 
    611611            CALL GET_COMMAND_ARGUMENT(1,cl_namelist) !f03 intrinsec 
    612612            CALL create_boundary__mono(cl_namelist) 
     
    625625   IF( il_narg == 0 )THEN 
    626626      WRITE(cl_errormsg,*) ' ERROR : at least one argument is needed ' 
    627       CALL fct_help(cp_myname,cl_errormsg)  
     627      CALL fct_help(cp_myname,cl_errormsg) 
    628628      CALL EXIT(1) 
    629629   ELSE 
     
    675675   !> @brief 
    676676   !> This subroutine create boundary files. 
    677    !>  
    678    !> @details  
     677   !> 
     678   !> @details 
    679679   !> 
    680680   !> @author J.Paul 
    681681   !> @date January, 2016 - Initial Version 
    682682   !> 
    683    !> @param[in] cd_namelist namelist file  
     683   !> @param[in] cd_namelist namelist file 
    684684   !------------------------------------------------------------------- 
    685685 
     
    688688   IMPLICIT NONE 
    689689   ! Argument 
    690    CHARACTER(LEN=lc), INTENT(IN) :: cd_namelist  
     690   CHARACTER(LEN=lc), INTENT(IN) :: cd_namelist 
    691691 
    692692   ! local variable 
     
    713713 
    714714   TYPE(TATT)                                         :: tl_att 
    715     
    716    TYPE(TVAR)                                         :: tl_depth    
     715 
     716   TYPE(TVAR)                                         :: tl_depth 
    717717   TYPE(TVAR)                                         :: tl_time 
    718718   TYPE(TVAR)                                         :: tl_var1 
     
    720720   TYPE(TVAR)                                         :: tl_lon1 
    721721   TYPE(TVAR)                                         :: tl_lat1 
    722    TYPE(TVAR)                                         :: tl_lvl1   
     722   TYPE(TVAR)                                         :: tl_lvl1 
    723723   TYPE(TVAR)       , DIMENSION(:)      , ALLOCATABLE :: tl_level 
    724724   TYPE(TVAR)       , DIMENSION(:,:,:)  , ALLOCATABLE :: tl_seglvl1 
     
    728728 
    729729   TYPE(TDATE)                                        :: tl_date 
    730     
     730 
    731731   TYPE(TBDY)       , DIMENSION(ip_ncard)             :: tl_bdy 
    732     
     732 
    733733   TYPE(TDOM)                                         :: tl_dom0 
    734734   TYPE(TDOM)                                         :: tl_dom1 
     
    737737   TYPE(TFILE)                                        :: tl_file 
    738738   TYPE(TFILE)                                        :: tl_fileout 
    739     
     739 
    740740   TYPE(TMPP)                                         :: tl_coord0 
    741741   TYPE(TMPP)                                         :: tl_coord1 
     
    755755   ! namelist variable 
    756756   ! namlog 
    757    CHARACTER(LEN=lc)                       :: cn_logfile    = 'create_boundary.log'  
    758    CHARACTER(LEN=lc)                       :: cn_verbosity  = 'warning'  
     757   CHARACTER(LEN=lc)                       :: cn_logfile    = 'create_boundary.log' 
     758   CHARACTER(LEN=lc)                       :: cn_verbosity  = 'warning' 
    759759   INTEGER(i4)                             :: in_maxerror   = 5 
    760760 
    761761   ! namcfg 
    762    CHARACTER(LEN=lc)                       :: cn_varcfg  = './cfg/variable.cfg'  
     762   CHARACTER(LEN=lc)                       :: cn_varcfg  = './cfg/variable.cfg' 
    763763   CHARACTER(LEN=lc)                       :: cn_dimcfg  = './cfg/dimension.cfg' 
    764764   CHARACTER(LEN=lc)                       :: cn_dumcfg  = './cfg/dummy.cfg' 
    765765 
    766766   ! namsrc 
    767    CHARACTER(LEN=lc)                       :: cn_coord0  = ''  
     767   CHARACTER(LEN=lc)                       :: cn_coord0  = '' 
    768768   INTEGER(i4)                             :: in_perio0  = -1 
    769769 
    770770   ! namtgt 
    771    CHARACTER(LEN=lc)                       :: cn_coord1  = ''  
    772    CHARACTER(LEN=lc)                       :: cn_bathy1  = ''  
     771   CHARACTER(LEN=lc)                       :: cn_coord1  = '' 
     772   CHARACTER(LEN=lc)                       :: cn_bathy1  = '' 
    773773   INTEGER(i4)                             :: in_perio1  = -1 
    774774 
     
    811811 
    812812   ! namout 
    813    CHARACTER(LEN=lc)                       :: cn_fileout = 'boundary.nc'  
     813   CHARACTER(LEN=lc)                       :: cn_fileout = 'boundary.nc' 
    814814   REAL(dp)                                :: dn_dayofs  = 0._dp 
    815815   LOGICAL                                 :: ln_extrap  = .FALSE. 
     
    834834   &  cn_bathy1,     &  !< bathymetry file 
    835835   &  in_perio1         !< periodicity index 
    836   
     836 
    837837   NAMELIST /namzgr/ & 
    838838   &  dn_pp_to_be_computed, & 
     
    854854 
    855855   NAMELIST /namvar/ &  !< variable namelist 
    856    &  cn_varfile,    &  !< list of variable and file where find it. (ex: 'votemper:GLORYS_gridT.nc' )  
     856   &  cn_varfile,    &  !< list of variable and file where find it. (ex: 'votemper:GLORYS_gridT.nc' ) 
    857857   &  cn_varinfo        !< list of variable and method to apply on. (ex: 'votemper:linear','vosaline:cubic' ) 
    858   
     858 
    859859   NAMELIST /namnst/ &  !< nesting namelist 
    860860   &  in_rhoi,       &  !< refinement factor in i-direction 
     
    873873 
    874874   NAMELIST /namout/ &  !< output namelist 
    875    &  cn_fileout,    &  !< fine grid boundary file basename    
     875   &  cn_fileout,    &  !< fine grid boundary file basename 
    876876   &  dn_dayofs,     &  !< date offset in day (change only ouput file name) 
    877877   &  ln_extrap         !< extrapolate or not 
     
    882882 
    883883   IF( ll_exist )THEN 
    884        
     884 
    885885      il_fileid=fct_getunit() 
    886886 
     
    938938 
    939939      WRITE(cl_errormsg,*) " ERROR : can't find "//TRIM(cd_namelist) 
    940       CALL fct_help(cp_myname,cl_errormsg)  
     940      CALL fct_help(cp_myname,cl_errormsg) 
    941941      CALL EXIT(1) 
    942942 
     
    958958      CALL grid_get_info(tl_coord0) 
    959959   ELSE 
    960       CALL logger_fatal("CREATE BOUNDARY: can not find coarse grid "//& 
     960      CALL logger_fatal("CREATE BOUNDARY: can not find source/coarse grid "//& 
    961961      &  "coordinate file. check namelist") 
    962962   ENDIF 
     
    10311031      &                         il_imin0, il_imax0, & 
    10321032      &                         il_jmin0, il_jmax0, & 
    1033       &                         il_rho(:) )       
     1033      &                         il_rho(:) ) 
    10341034 
    10351035   ! read or compute boundary 
     
    10371037 
    10381038   CALL iom_mpp_open(tl_bathy1) 
    1039   
     1039 
    10401040   tl_var1=iom_mpp_read_var(tl_bathy1,'Bathymetry') 
    1041   
     1041 
    10421042   CALL iom_mpp_close(tl_bathy1) 
    10431043 
     
    10451045   tl_bdy(:)=boundary_init(tl_var1, ln_north, ln_south, ln_east, ln_west, & 
    10461046      &                             cn_north, cn_south, cn_east, cn_west, & 
    1047       &                             ln_oneseg )  
     1047      &                             ln_oneseg ) 
    10481048 
    10491049 
     
    10571057   ALLOCATE( tl_segdom1(ip_npoint,ip_maxseg,ip_ncard) ) 
    10581058   ALLOCATE( tl_seglvl1(ip_npoint,ip_maxseg,ip_ncard) ) 
    1059   
     1059 
    10601060   DO jl=1,ip_ncard 
    10611061      IF( tl_bdy(jl)%l_use )THEN 
     
    11641164 
    11651165            WRITE(*,'(a)') "work on file "//TRIM(tl_multi%t_mpp(ji)%c_name) 
    1166             !  
     1166            ! 
    11671167            tl_file=file_init(TRIM(tl_multi%t_mpp(ji)%t_proc(1)%c_name), & 
    11681168               &              id_perio=tl_multi%t_mpp(ji)%i_perio) 
     
    11821182                     ! for each variable of this file 
    11831183                     DO jj=1,tl_multi%t_mpp(ji)%t_proc(1)%i_nvar 
    1184   
     1184 
    11851185                        WRITE(*,'(4x,a,a)') "work on variable "//& 
    11861186                        &  TRIM(tl_multi%t_mpp(ji)%t_proc(1)%t_var(jj)%c_name) 
     
    12201220                        &                               tl_lon1, tl_lat1 ) 
    12211221 
    1222                         ! get coarse grid indices of this segment 
     1222                        ! get source/coarse grid indices of this segment 
    12231223                        il_ind(:,:)=grid_get_coarse_index(tl_coord0, & 
    12241224                        &                                 tl_lon1, tl_lat1, & 
     
    12271227                        IF( ANY(il_ind(:,:)==0) )THEN 
    12281228                           CALL logger_error("CREATE BOUNDARY: error "//& 
    1229                            &  "computing coarse grid indices") 
     1229                           &  "computing source/coarse grid indices") 
    12301230                        ELSE 
    12311231                           il_imin0=il_ind(1,1) 
     
    12451245                        &                    TRIM(tl_var0%c_point) ) 
    12461246 
    1247                         ! compute coarse grid segment domain 
     1247                        ! compute source/coarse grid segment domain 
    12481248                        tl_dom0=dom_init( tl_coord0,         & 
    12491249                        &                 il_imin0, il_imax0,& 
     
    12771277                        &                   tl_dom1 ) 
    12781278 
    1279                         ! clean extra point information on coarse grid domain 
     1279                        ! clean extra point information on source/coarse grid domain 
    12801280                        CALL dom_clean_extra( tl_dom0 ) 
    12811281 
     
    12861286                        &                 tl_att) 
    12871287 
    1288                         !  
     1288                        ! 
    12891289                        tl_att=att_init('src_i_indices',& 
    12901290                        &  (/tl_dom0%i_imin, tl_dom0%i_imax/)) 
     
    13251325 
    13261326                  ENDDO ! jk 
    1327              
     1327 
    13281328               ENDIF 
    13291329            ENDDO ! jl 
     
    13491349 
    13501350         DO jk=1,tl_bdy(jl)%i_nseg 
    1351             !-  
     1351            !- 
    13521352            CALL create_boundary_get_coord( tl_coord1, tl_segdom1(jp_T,jk,jl),& 
    13531353               &                           'T', tl_lon1, tl_lat1 ) 
     
    14111411                  tl_date=var_to_date(tl_time) 
    14121412                  tl_date=tl_date+dn_dayofs 
    1413                   cl_date=date_print( tl_date, cl_fmt )  
     1413                  cl_date=date_print( tl_date, cl_fmt ) 
    14141414 
    14151415                  cl_bdyout=boundary_set_filename( TRIM(cn_fileout), & 
     
    14351435               ENDIF 
    14361436            ENDIF 
    1437             !  
     1437            ! 
    14381438            tl_fileout=file_init(TRIM(cl_bdyout),id_perio=in_perio1) 
    14391439 
     
    14621462               CALL var_clean(tl_lat1) 
    14631463            ENDIF 
    1464              
     1464 
    14651465 
    14661466 
     
    15151515            tl_att=att_init('bdy_width',tl_bdy(jl)%t_seg(jk)%i_width) 
    15161516            CALL file_move_att(tl_fileout, tl_att) 
    1517              
    1518             ! add indice of segment start  
     1517 
     1518            ! add indice of segment start 
    15191519            tl_att=att_init('bdy_deb',tl_bdy(jl)%t_seg(jk)%i_first) 
    15201520            CALL file_move_att(tl_fileout, tl_att) 
    1521              
    1522             ! add indice of segment end  
     1521 
     1522            ! add indice of segment end 
    15231523            tl_att=att_init('bdy_end',tl_bdy(jl)%t_seg(jk)%i_last) 
    15241524            CALL file_move_att(tl_fileout, tl_att) 
    1525                             
     1525 
    15261526            ! clean 
    15271527            CALL att_clean(tl_att) 
     
    15701570   !------------------------------------------------------------------- 
    15711571   !> @brief 
    1572    !> This subroutine compute boundary domain for each grid point (T,U,V,F)  
    1573    !>  
     1572   !> This subroutine compute boundary domain for each grid point (T,U,V,F) 
     1573   !> 
    15741574   !> @author J.Paul 
    15751575   !> @date November, 2013 - Initial Version 
     
    15771577   !> - take into account grid point to compute boundary indices 
    15781578   !> 
    1579    !> @param[in] td_bathy1 file structure  
     1579   !> @param[in] td_bathy1 file structure 
    15801580   !> @param[in] td_bdy    boundary structure 
    1581    !> @param[in] id_seg    segment indice  
    1582    !> @return array of domain structure  
     1581   !> @param[in] id_seg    segment indice 
     1582   !> @return array of domain structure 
    15831583   !------------------------------------------------------------------- 
    15841584 
     
    16221622 
    16231623            il_imin1=td_bdy%t_seg(jk)%i_first 
    1624             il_imax1=td_bdy%t_seg(jk)%i_last  
     1624            il_imax1=td_bdy%t_seg(jk)%i_last 
    16251625            il_jmin1=td_bdy%t_seg(jk)%i_index-(td_bdy%t_seg(jk)%i_width-1) 
    16261626            il_jmax1=td_bdy%t_seg(jk)%i_index 
     
    16321632 
    16331633            il_imin1=td_bdy%t_seg(jk)%i_first 
    1634             il_imax1=td_bdy%t_seg(jk)%i_last  
     1634            il_imax1=td_bdy%t_seg(jk)%i_last 
    16351635            il_jmin1=td_bdy%t_seg(jk)%i_index 
    16361636            il_jmax1=td_bdy%t_seg(jk)%i_index+(td_bdy%t_seg(jk)%i_width-1) 
     
    16411641            il_imax1=td_bdy%t_seg(jk)%i_index 
    16421642            il_jmin1=td_bdy%t_seg(jk)%i_first 
    1643             il_jmax1=td_bdy%t_seg(jk)%i_last  
     1643            il_jmax1=td_bdy%t_seg(jk)%i_last 
    16441644 
    16451645            il_ishift(jp_U)=-1 
     
    16511651            il_imax1=td_bdy%t_seg(jk)%i_index+(td_bdy%t_seg(jk)%i_width-1) 
    16521652            il_jmin1=td_bdy%t_seg(jk)%i_first 
    1653             il_jmax1=td_bdy%t_seg(jk)%i_last  
    1654  
    1655       END SELECT          
     1653            il_jmax1=td_bdy%t_seg(jk)%i_last 
     1654 
     1655      END SELECT 
    16561656 
    16571657      !-read fine grid domain 
     
    16801680   !> @brief 
    16811681   !> This subroutine get coordinates over boundary domain 
    1682    !>  
     1682   !> 
    16831683   !> @author J.Paul 
    16841684   !> @date November, 2013 - Initial Version 
    1685    !> @date September, 2014  
     1685   !> @date September, 2014 
    16861686   !> - take into account grid point 
    16871687   !> 
     
    17001700      CHARACTER(LEN=*), INTENT(IN   ) :: cd_point 
    17011701      TYPE(TVAR)      , INTENT(  OUT) :: td_lon1 
    1702       TYPE(TVAR)      , INTENT(  OUT) :: td_lat1  
     1702      TYPE(TVAR)      , INTENT(  OUT) :: td_lat1 
    17031703 
    17041704      ! local variable 
    17051705      TYPE(TMPP)        :: tl_coord1 
    1706        
     1706 
    17071707      CHARACTER(LEN=lc) :: cl_name 
    17081708      ! loop indices 
     
    17111711      ! init mpp structure 
    17121712      tl_coord1=mpp_copy(td_coord1) 
    1713        
     1713 
    17141714      ! open mpp files 
    17151715      CALL iom_dom_open(tl_coord1, td_dom1) 
     
    17341734   !> @brief 
    17351735   !> This subroutine interpolate variable on boundary 
    1736    !>  
    1737    !> @details  
     1736   !> 
     1737   !> @details 
    17381738   !> 
    17391739   !> @author J.Paul 
    17401740   !> @date November, 2013 - Initial Version 
    17411741   !> 
    1742    !> @param[inout] td_var variable structure  
     1742   !> @param[inout] td_var variable structure 
    17431743   !> @param[in] id_rho    array of refinment factor 
    1744    !> @param[in] id_offset array of offset between fine and coarse grid 
     1744   !> @param[in] id_offset array of offset between fine and source/coarse grid 
    17451745   !> @param[in] id_iext   i-direction size of extra bands (default=im_minext) 
    17461746   !> @param[in] id_jext   j-direction size of extra bands (default=im_minext) 
     
    18051805   !> @brief 
    18061806   !> This function create variable, filled with matrix value 
    1807    !>  
    1808    !> @details  
    1809    !> A variable is create with the same name that the input variable,  
    1810    !> and with dimension of the coordinate file.  
     1807   !> 
     1808   !> @details 
     1809   !> A variable is create with the same name that the input variable, 
     1810   !> and with dimension of the coordinate file. 
    18111811   !> Then the variable array of value is split into equal subdomain. 
    18121812   !> Each subdomain is fill with the associated value of the matrix. 
     
    18151815   !> @date November, 2013 - Initial Version 
    18161816   !> 
    1817    !> @param[in] td_var    variable structure  
    1818    !> @param[in] td_dom    domain structure  
    1819    !> @param[in] id_nlevel number of levels  
    1820    !> @return variable structure  
     1817   !> @param[in] td_var    variable structure 
     1818   !> @param[in] td_dom    domain structure 
     1819   !> @param[in] id_nlevel number of levels 
     1820   !> @return variable structure 
    18211821   !------------------------------------------------------------------- 
    18221822 
     
    18571857      tl_dim(jp_K)%i_len=id_nlevel 
    18581858 
    1859       ! split output domain in N subdomain depending of matrix dimension  
     1859      ! split output domain in N subdomain depending of matrix dimension 
    18601860      il_size(:) = tl_dim(1:3)%i_len / il_dim(:) 
    18611861      il_rest(:) = MOD(tl_dim(1:3)%i_len, il_dim(:)) 
     
    18681868      ! add rest to last cell 
    18691869      il_ishape(il_dim(1)+1)=il_ishape(il_dim(1)+1)+il_rest(1) 
    1870        
     1870 
    18711871      ALLOCATE( il_jshape(il_dim(2)+1) ) 
    18721872      il_jshape(:)=0 
     
    18851885      il_kshape(il_dim(3)+1)=il_kshape(il_dim(3)+1)+il_rest(3) 
    18861886 
    1887       ! write ouput array of value  
     1887      ! write ouput array of value 
    18881888      ALLOCATE(dl_value( tl_dim(1)%i_len, & 
    18891889      &                  tl_dim(2)%i_len, & 
     
    18961896         DO jj=2,il_dim(2)+1 
    18971897            DO ji=2,il_dim(1)+1 
    1898                 
     1898 
    18991899               dl_value( 1+il_ishape(ji-1):il_ishape(ji), & 
    19001900               &         1+il_jshape(jj-1):il_jshape(jj), & 
     
    19171917   !> @brief 
    19181918   !> This subroutine use mask to filled land point with _FillValue 
    1919    !>  
    1920    !> @details  
     1919   !> 
     1920   !> @details 
    19211921   !> 
    19221922   !> @author J.Paul 
    19231923   !> @date November, 2013 - Initial Version 
    19241924   !> 
    1925    !> @param[inout] td_var variable structure  
     1925   !> @param[inout] td_var variable structure 
    19261926   !> @param[in] td_mask   mask variable structure 
    19271927   !------------------------------------------------------------------- 
     
    20292029   !------------------------------------------------------------------- 
    20302030   !> @brief 
    2031    !> This subroutine check if variable need depth dimension,  
     2031   !> This subroutine check if variable need depth dimension, 
    20322032   !> get depth variable value in an open mpp structure 
    20332033   !> and check if agree with already input depth variable. 
    2034    !>  
    2035    !> @details  
     2034   !> 
     2035   !> @details 
    20362036   !> 
    20372037   !> @author J.Paul 
     
    20432043   !> @param[in] td_mpp       mpp structure 
    20442044   !> @param[in] id_nlevel    mpp structure 
    2045    !> @param[inout] td_depth  depth variable structure  
     2045   !> @param[inout] td_depth  depth variable structure 
    20462046   !------------------------------------------------------------------- 
    20472047 
     
    21022102         &                 " for variable "//TRIM(td_var%c_name)) 
    21032103      ENDIF 
    2104        
     2104 
    21052105   END SUBROUTINE create_boundary_check_depth 
    21062106   !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     
    21082108   !------------------------------------------------------------------- 
    21092109   !> @brief 
    2110    !> This subroutine check if variable need time dimension,  
     2110   !> This subroutine check if variable need time dimension, 
    21112111   !> get date and time in an open mpp structure 
    21122112   !> and check if agree with date and time already read. 
    2113    !>  
    2114    !> @details  
     2113   !> 
     2114   !> @details 
    21152115   !> 
    21162116   !> @author J.Paul 
     
    21212121   !> @param[in] td_var       variable structure 
    21222122   !> @param[in] td_mpp      mpp structure 
    2123    !> @param[inout] td_time  time variable structure  
     2123   !> @param[inout] td_time  time variable structure 
    21242124   !------------------------------------------------------------------- 
    21252125 
  • utils/tools/SIREN/src/create_coord.f90

    r12080 r13369  
    55! DESCRIPTION: 
    66!> @file 
    7 !> @brief  
    8 !> this program creates fine grid coordinate file. 
     7!> @brief 
     8!> this program creates target/fine grid coordinate file. 
    99!> 
    1010!> @details 
     
    1212!> variables from the input coordinates coarse/source grid file, are extracted 
    1313!> and interpolated to create a fine/taget grid coordinates file.<br/> 
    14 !> @note  
     14!> @note 
    1515!>    interpolation method could be different for each variable. 
    1616!> 
    17 !> \image html  header_coord_40.png  
    18 !> <center> \image latex header_coord_40.png  
     17!> \image html  header_coord_40.png 
     18!> <center> \image latex header_coord_40.png 
    1919!> </center> 
    2020!> 
     
    4646!> 
    4747!>    here after, each sub-namelist parameters is detailed. 
    48 !>    @note  
     48!>    @note 
    4949!>       default values are specified between brackets 
    5050!> 
     
    6565!>          - none 
    6666!> 
    67 !>    - **in_maxerror** [@a 5]<br/>  
     67!>    - **in_maxerror** [@a 5]<br/> 
    6868!>       maximum number of error allowed 
    6969!> 
     
    7373!>    - **cn_varcfg** [@a ./cfg/variable.cfg]<br/> 
    7474!>       path to the variable configuration file.<br/> 
    75 !>       the variable configuration file defines standard name,  
    76 !>       default interpolation method, axis,...  
    77 !>       to be used for some known variables.<br/>  
    78 !> 
    79 !>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/>  
    80 !>       path to the dimension configuration file.<br/>  
    81 !>       the dimension configuration file defines dimensions allowed.<br/>  
    82 !> 
    83 !>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/>  
     75!>       the variable configuration file defines standard name, 
     76!>       default interpolation method, axis,... 
     77!>       to be used for some known variables.<br/> 
     78!> 
     79!>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/> 
     80!>       path to the dimension configuration file.<br/> 
     81!>       the dimension configuration file defines dimensions allowed.<br/> 
     82!> 
     83!>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/> 
    8484!>       path to the useless (dummy) configuration file.<br/> 
    85 !>       the dummy configuration file defines useless  
     85!>       the dummy configuration file defines useless 
    8686!>       dimension or variable. these dimension(s) or variable(s) will not be 
    8787!>       processed.<br/> 
    8888!> 
    89 !> @subsection subsrc namsrc  
     89!> @subsection subsrc namsrc 
    9090!>    the source/coarse grid sub-namelist parameters are : 
    9191!> 
    92 !>    - **cn_coord0** [@a ]<br/>  
     92!>    - **cn_coord0** [@a ]<br/> 
    9393!>       path to the coordinate file 
    9494!> 
    95 !>    - **in_perio0** [@a ]<br/>  
    96 !>       NEMO periodicity index<br/>  
     95!>    - **in_perio0** [@a ]<br/> 
     96!>       NEMO periodicity index<br/> 
    9797!>       the NEMO periodicity could be choose between 0 to 6: 
    9898!>       <dl> 
     
    116116!>       </dl> 
    117117!>       @sa For more information see @ref md_src_docsrc_6_perio 
    118 !>       and Model Boundary Condition paragraph in the  
     118!>       and Model Boundary Condition paragraph in the 
    119119!>       [NEMO documentation](https://forge.ipsl.jussieu.fr/nemo/chrome/site/doc/NEMO/manual/pdf/NEMO_manual.pdf) 
    120120!> 
    121 !> @subsection subvar namvar  
     121!> @subsection subvar namvar 
    122122!>    the variable sub-namelist parameters are : 
    123123!> 
    124 !>    - **cn_varinfo** [@a ]<br/>  
     124!>    - **cn_varinfo** [@a ]<br/> 
    125125!>       list of variable and extra information about request(s) to be used<br/> 
    126126!> 
    127127!>       each elements of *cn_varinfo* is a string character (separated by ',').<br/> 
    128 !>       it is composed of the variable name follow by ':',  
    129 !>       then request(s) to be used on this variable.<br/>  
     128!>       it is composed of the variable name follow by ':', 
     129!>       then request(s) to be used on this variable.<br/> 
    130130!>       request could be: 
    131131!>          - int = interpolation method 
     
    137137!>       informations about available method could be find in @ref interp, 
    138138!>       @ref extrap and @ref filter modules.<br/> 
    139 !>       Example:  
     139!>       Example: 
    140140!>          - 'glamt: int=linear; ext=dist_weight', 'e1t: int=cubic/rhoi' 
    141141!> 
    142 !>       @note  
    143 !>          If you do not specify a method which is required,  
     142!>       @note 
     143!>          If you do not specify a method which is required, 
    144144!>          default one is apply. 
    145145!> 
    146 !> @subsection subnst namnst  
     146!> @subsection subnst namnst 
    147147!>    the nesting sub-namelist parameters are : 
    148148!> 
    149149!>    - **in_imin0** [@a ]<br/> 
    150 !>       i-direction lower left  point indice of coarse grid subdomain to be used 
     150!>       i-direction lower left  point indice of source/coarse grid subdomain to be used 
    151151!>    - **in_imax0** [@a ]<br/> 
    152 !>       i-direction upper right point indice of coarse grid subdomain to be used 
     152!>       i-direction upper right point indice of source/coarse grid subdomain to be used 
    153153!>    - **in_jmin0** [@a ]<br/> 
    154 !>       j-direction lower left  point indice of coarse grid subdomain to be used 
     154!>       j-direction lower left  point indice of source/coarse grid subdomain to be used 
    155155!>    - **in_jmax0** [@a ]<br/> 
    156 !>       j-direction upper right point indice of coarse grid subdomain to be used 
     156!>       j-direction upper right point indice of source/coarse grid subdomain to be used 
    157157!> <br/>or<br/> 
    158158!>    - **rn_lonmin0** [@a ]<br/> 
    159 !>       lower left  longitude of coarse grid subdomain to be used 
     159!>       lower left  longitude of source/coarse grid subdomain to be used 
    160160!>    - **rn_lonmax0** [@a ]<br/> 
    161 !>       upper right longitude of coarse grid subdomain to be used 
     161!>       upper right longitude of source/coarse grid subdomain to be used 
    162162!>    - **rn_latmin0** [@a ]<br/> 
    163 !>       lower left  latitude  of coarse grid subdomain to be used 
     163!>       lower left  latitude  of source/coarse grid subdomain to be used 
    164164!>    - **rn_latmax0** [@a ]<br/> 
    165 !>       upper right latitude  of coarse grid subdomain to be used 
    166 !>    @note you could define sub domain with  
     165!>       upper right latitude  of source/coarse grid subdomain to be used 
     166!>    @note you could define sub domain with 
    167167!>       - coarse/source grid indices 
    168168!>       <br/>or<br/> 
     
    171171!>    SIREN does not take into account indices. 
    172172!> 
    173 !>    - **in_rhoi**  [@a 1]<br/>  
     173!>    - **in_rhoi**  [@a 1]<br/> 
    174174!>       refinement factor in i-direction 
    175175!> 
    176 !>    - **in_rhoj**  [@a 1]<br/>  
     176!>    - **in_rhoj**  [@a 1]<br/> 
    177177!>       refinement factor in j-direction 
    178178!> 
    179 !>       \image html  grid_zoom_60.png  
    180 !>       <center> \image latex grid_zoom_40.png  
     179!>       \image html  grid_zoom_60.png 
     180!>       <center> \image latex grid_zoom_40.png 
    181181!>       </center> 
    182182!> 
    183 !> @subsection subout namout  
     183!> @subsection subout namout 
    184184!>    the output sub-namelist parameter is : 
    185185!> 
     
    281281   ! namelist variable 
    282282   ! namlog 
    283    CHARACTER(LEN=lc) :: cn_logfile  = 'create_coord.log'  
    284    CHARACTER(LEN=lc) :: cn_verbosity= 'warning'  
     283   CHARACTER(LEN=lc) :: cn_logfile  = 'create_coord.log' 
     284   CHARACTER(LEN=lc) :: cn_verbosity= 'warning' 
    285285   INTEGER(i4)       :: in_maxerror = 5 
    286286 
    287287   ! namcfg 
    288    CHARACTER(LEN=lc) :: cn_varcfg   = './cfg/variable.cfg'  
    289    CHARACTER(LEN=lc) :: cn_dimcfg   = './cfg/dimension.cfg'  
     288   CHARACTER(LEN=lc) :: cn_varcfg   = './cfg/variable.cfg' 
     289   CHARACTER(LEN=lc) :: cn_dimcfg   = './cfg/dimension.cfg' 
    290290   CHARACTER(LEN=lc) :: cn_dumcfg   = './cfg/dummy.cfg' 
    291291 
    292292   ! namsrc 
    293    CHARACTER(LEN=lc) :: cn_coord0   = ''  
     293   CHARACTER(LEN=lc) :: cn_coord0   = '' 
    294294   INTEGER(i4)       :: in_perio0   = -1 
    295295 
     
    328328 
    329329   NAMELIST /namvar/ &  !< variable namelist 
    330    &  cn_varinfo        !< list of variable and extra information about  
    331                         !< interpolation, extrapolation or filter method to be used.  
    332                         !< (ex: 'votemper:linear,hann,dist_weight','vosaline:cubic' )  
    333   
     330   &  cn_varinfo        !< list of variable and extra information about 
     331                        !< interpolation, extrapolation or filter method to be used. 
     332                        !< (ex: 'votemper:linear,hann,dist_weight','vosaline:cubic' ) 
     333 
    334334   NAMELIST /namnst/ &  !< nesting namelist 
    335    &  rn_lonmin0,    &  !< lower left  coarse grid longitude 
    336    &  rn_lonmax0,    &  !< upper right coarse grid longitude 
    337    &  rn_latmin0,    &  !< lower left  coarse grid latitude 
    338    &  rn_latmax0,    &  !< upper right coarse grid latitude 
    339    &  in_imin0,      &  !< i-direction lower left  point indice  
     335   &  rn_lonmin0,    &  !< lower left  source/coarse grid longitude 
     336   &  rn_lonmax0,    &  !< upper right source/coarse grid longitude 
     337   &  rn_latmin0,    &  !< lower left  source/coarse grid latitude 
     338   &  rn_latmax0,    &  !< upper right source/coarse grid latitude 
     339   &  in_imin0,      &  !< i-direction lower left  point indice 
    340340   &  in_imax0,      &  !< i-direction upper right point indice 
    341341   &  in_jmin0,      &  !< j-direction lower left  point indice 
     
    345345 
    346346   NAMELIST /namout/ &  !< output namelist 
    347    &  cn_fileout        !< fine grid coordinate file    
     347   &  cn_fileout        !< target/fine grid coordinate file 
    348348   !------------------------------------------------------------------- 
    349349 
     
    358358   IF( il_narg /= 1 )THEN 
    359359      WRITE(cl_errormsg,*) ' ERROR : one argument is needed ' 
    360       CALL fct_help(cp_myname,cl_errormsg)  
     360      CALL fct_help(cp_myname,cl_errormsg) 
    361361      CALL EXIT(1) 
    362362   ELSE 
     
    393393               IF( il_status /= 0 )THEN 
    394394                  WRITE(cl_errormsg,*) " ERROR : error opening "//TRIM(cl_namelist) 
    395                   CALL fct_help(cp_myname,cl_errormsg)  
     395                  CALL fct_help(cp_myname,cl_errormsg) 
    396396                  CALL EXIT(1) 
    397397               ENDIF 
    398398 
    399399               READ( il_fileid, NML = namlog ) 
    400   
     400 
    401401               ! define logger file 
    402402               CALL logger_open(TRIM(cn_logfile),TRIM(cn_verbosity),in_maxerror) 
     
    434434 
    435435               WRITE(cl_errormsg,*) " ERROR : can't find "//TRIM(cl_namelist) 
    436                CALL fct_help(cp_myname,cl_errormsg)  
     436               CALL fct_help(cp_myname,cl_errormsg) 
    437437               CALL EXIT(1) 
    438438 
     
    450450      CALL grid_get_info(tl_coord0) 
    451451   ELSE 
    452       CALL logger_fatal("CREATE COORD: no coarse grid coordinate found. "//& 
    453       &     "check namelist")       
     452      CALL logger_fatal("CREATE COORD: no source/coarse grid coordinate found. "//& 
     453      &     "check namelist") 
    454454   ENDIF 
    455455 
     
    469469      il_index(:)=grid_get_closest(tl_coord0, & 
    470470         &                         REAL(rn_lonmin0,dp), REAL(rn_latmin0,dp), & 
    471          &                         cd_pos='ll')  
     471         &                         cd_pos='ll') 
    472472      il_imin0=il_index(1) 
    473473      il_jmin0=il_index(2) 
     
    483483      il_index(:)=grid_get_closest(tl_coord0, & 
    484484         &                         REAL(rn_lonmax0,dp), REAL(rn_latmax0,dp), & 
    485          &                         cd_pos='ur')  
     485         &                         cd_pos='ur') 
    486486      il_imax0=il_index(1) 
    487487      il_jmax0=il_index(2) 
     
    509509   ELSE 
    510510      il_rho(jp_I)=in_rhoi 
    511       il_rho(jp_J)=in_rhoj       
     511      il_rho(jp_J)=in_rhoj 
    512512 
    513513      il_offset(:,:,:)=create_coord_get_offset(il_rho(:)) 
     
    555555 
    556556      ! filter 
    557       CALL filter_fill_value(tl_var(ji))       
     557      CALL filter_fill_value(tl_var(ji)) 
    558558 
    559559   ENDDO 
     
    600600 
    601601   tl_att=att_init("src_file",TRIM(fct_basename(cn_coord0))) 
    602    CALL file_add_att(tl_fileout, tl_att)    
     602   CALL file_add_att(tl_fileout, tl_att) 
    603603 
    604604   tl_att=att_init("src_i_indices",(/tl_dom%i_imin,tl_dom%i_imax/)) 
    605    CALL file_add_att(tl_fileout, tl_att)    
     605   CALL file_add_att(tl_fileout, tl_att) 
    606606   tl_att=att_init("src_j_indices",(/tl_dom%i_jmin,tl_dom%i_jmax/)) 
    607607   CALL file_add_att(tl_fileout, tl_att) 
     
    650650   CALL att_clean(tl_att) 
    651651   CALL var_clean(tl_var(:)) 
    652    DEALLOCATE( tl_var)  
     652   DEALLOCATE( tl_var) 
    653653 
    654654   CALL file_clean(tl_fileout) 
     
    657657   ! close log file 
    658658   CALL logger_footer() 
    659    CALL logger_close()  
     659   CALL logger_close() 
    660660 
    661661CONTAINS 
     
    665665   !------------------------------------------------------------------- 
    666666   !> @brief 
    667    !> This function compute offset over Arakawa grid points,  
     667   !> This function compute offset over Arakawa grid points, 
    668668   !> given refinement factor. 
    669    !>  
     669   !> 
    670670   !> @author J.Paul 
    671671   !> @date August, 2014 - Initial Version 
     
    677677      IMPLICIT NONE 
    678678 
    679       ! Argument       
     679      ! Argument 
    680680      INTEGER(i4), DIMENSION(:), INTENT(IN) :: id_rho 
    681681 
     
    711711   !> @brief 
    712712   !> This subroutine interpolate variable, given refinment factor. 
    713    !>  
    714    !> @details  
    715    !>  Optionaly, you could specify number of points  
     713   !> 
     714   !> @details 
     715   !>  Optionaly, you could specify number of points 
    716716   !>    to be extrapolated in i- and j-direction.<br/> 
    717717   !>  variable mask is first computed (using _FillValue) and interpolated.<br/> 
    718    !>  variable is then extrapolated, and interpolated.<br/>  
     718   !>  variable is then extrapolated, and interpolated.<br/> 
    719719   !>  Finally interpolated mask is applied on refined variable. 
    720720   !> 
     
    722722   !> @date November, 2013 - Initial Version 
    723723   !> 
    724    !> @param[inout] td_var variable strcuture  
     724   !> @param[inout] td_var variable strcuture 
    725725   !> @param[in] id_rho    array of refinement factor 
    726    !> @param[in] id_offset offset between fine grid and coarse grid 
     726   !> @param[in] id_offset offset between target/fine grid and source/coarse grid 
    727727   !> @param[in] id_iext   number of points to be extrapolated in i-direction 
    728728   !> @param[in] id_jext   number of points to be extrapolated in j-direction 
     
    762762      il_jext=2 
    763763      IF( PRESENT(id_jext) ) il_jext=id_jext 
    764        
     764 
    765765      IF( il_iext < 2 .AND. td_var%c_interp(1) == 'cubic' )THEN 
    766766         CALL logger_warn("CREATE COORD INTERP: at least extrapolation "//& 
     
    784784 
    785785         bl_mask(:,:,:,:)=1 
    786          WHERE(td_var%d_value(:,:,:,:)==td_var%d_fill) bl_mask(:,:,:,:)=0       
     786         WHERE(td_var%d_value(:,:,:,:)==td_var%d_fill) bl_mask(:,:,:,:)=0 
    787787 
    788788         SELECT CASE(TRIM(td_var%c_point)) 
     
    799799            tl_mask=var_init('fmask',bl_mask(:,:,:,:),td_dim=td_var%t_dim(:),& 
    800800            &                id_ew=td_var%i_ew ) 
    801          END SELECT          
     801         END SELECT 
    802802 
    803803         DEALLOCATE(bl_mask) 
     
    821821         CALL extrap_del_extrabands(td_var, il_iext*id_rho(jp_I), il_jext*id_rho(jp_J)) 
    822822 
    823          ! keep original mask  
     823         ! keep original mask 
    824824         WHERE( tl_mask%d_value(:,:,:,:) == 0 ) 
    825825            td_var%d_value(:,:,:,:)=td_var%d_fill 
  • utils/tools/SIREN/src/create_layout.f90

    r12080 r13369  
    55! DESCRIPTION: 
    66!> @file 
    7 !> @brief  
     7!> @brief 
    88!> This program creates/computes the domain layout for you configuration. 
    99!> 
     
    1515!> Then the number of sea/land processors is compute with mask. 
    1616!> 
    17 !> The optimized domain layout is assumed to be the domain layout, with the the most land  
     17!> The optimized domain layout is assumed to be the domain layout, with the the most land 
    1818!> processors removed. If no land processor could be removed, it assumed to be the domain layout 
    1919!> with the most sea processors. 
     
    4444!> 
    4545!>    here after, each sub-namelist parameters is detailed. 
    46 !>    @note  
     46!>    @note 
    4747!>       default values are specified between brackets 
    4848!> 
     
    6363!>          - none 
    6464!> 
    65 !>    - **in_maxerror** [@a 5]<br/>  
     65!>    - **in_maxerror** [@a 5]<br/> 
    6666!>       maximum number of error allowed 
    6767!> 
     
    7171!>    - **cn_varcfg** [@a ./cfg/variable.cfg]<br/> 
    7272!>       path to the variable configuration file.<br/> 
    73 !>       the variable configuration file defines standard name,  
    74 !>       default interpolation method, axis,...  
    75 !>       to be used for some known variables.<br/>  
    76 !> 
    77 !>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/>  
    78 !>       path to the dimension configuration file.<br/>  
    79 !>       the dimension configuration file defines dimensions allowed.<br/>  
    80 !> 
    81 !>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/>  
     73!>       the variable configuration file defines standard name, 
     74!>       default interpolation method, axis,... 
     75!>       to be used for some known variables.<br/> 
     76!> 
     77!>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/> 
     78!>       path to the dimension configuration file.<br/> 
     79!>       the dimension configuration file defines dimensions allowed.<br/> 
     80!> 
     81!>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/> 
    8282!>       path to the useless (dummy) configuration file.<br/> 
    83 !>       the dummy configuration file defines useless  
     83!>       the dummy configuration file defines useless 
    8484!>       dimension or variable. these dimension(s) or variable(s) will not be 
    8585!>       processed.<br/> 
    8686!> 
    87 !> @subsection subvar namvar  
     87!> @subsection subvar namvar 
    8888!>    the variable sub-namelist parameters are : 
    8989!> 
    90 !>    - **cn_varfile** [@a ]<br/>  
    91 !>       list of variable, and associated file  
    92 !>       @warning  
     90!>    - **cn_varfile** [@a ]<br/> 
     91!>       list of variable, and associated file 
     92!>       @warning 
    9393!>          variable name must be __Bathymetry__ here. 
    9494!> 
    9595!>    - **cn_varfile** [@a ]<br/>: 
    96 !>       list of variable, and associated file.<br/>  
     96!>       list of variable, and associated file.<br/> 
    9797!>       *cn_varfile* is the path and filename of the file where find 
    9898!>       variable to be used as mask grid.<br/> 
    9999!> 
    100 !>       Examples:  
     100!>       Examples: 
    101101!>          - 'Bathymetry:bathy_meter.nc' 
    102102!> 
    103 !> @subsection subout namout  
     103!> @subsection subout namout 
    104104!>    the output sub-namelist parameters are : 
    105105!> 
     
    114114!>       - if *in_niproc*, and *in_njproc* are provided : the program only look for land 
    115115!>         processor to be removed 
    116 !>       - if *in_nproc* is provided : the program compute each possible domain layout,  
    117 !>         and save the one with the most land processor to be removed  
     116!>       - if *in_nproc* is provided : the program compute each possible domain layout, 
     117!>         and save the one with the most land processor to be removed 
    118118!>       - with no information about number of processors, the program 
    119119!>         assume to use only one processor 
     
    136136   USE fct                             ! basic useful function 
    137137   USE date                            ! date manager 
    138    USE math                            !  
     138   USE math                            ! 
    139139   USE att                             ! attribute manager 
    140140   USE dim                             ! dimension manager 
     
    174174 
    175175   TYPE(TMULTI)                            :: tl_multi 
    176     
     176 
    177177   ! namelist variable 
    178178   ! namlog 
    179    CHARACTER(LEN=lc)                       :: cn_logfile = 'create_layout.log'  
    180    CHARACTER(LEN=lc)                       :: cn_verbosity = 'warning'  
     179   CHARACTER(LEN=lc)                       :: cn_logfile = 'create_layout.log' 
     180   CHARACTER(LEN=lc)                       :: cn_verbosity = 'warning' 
    181181   INTEGER(i4)                             :: in_maxerror = 5 
    182182 
    183183   ! namcfg 
    184    CHARACTER(LEN=lc)                       :: cn_varcfg = './cfg/variable.cfg'  
     184   CHARACTER(LEN=lc)                       :: cn_varcfg = './cfg/variable.cfg' 
    185185   CHARACTER(LEN=lc)                       :: cn_dimcfg = './cfg/dimension.cfg' 
    186186   CHARACTER(LEN=lc)                       :: cn_dumcfg = './cfg/dummy.cfg' 
     
    191191   ! namout 
    192192   INTEGER(i4)                             :: in_niproc = 0 
    193    INTEGER(i4)                             :: in_njproc = 0  
     193   INTEGER(i4)                             :: in_njproc = 0 
    194194   INTEGER(i4)                             :: in_nproc  = 0 
    195195   !------------------------------------------------------------------- 
     
    206206 
    207207   NAMELIST /namvar/ &  !< source grid namelist 
    208    &  cn_varfile        !< input file and mask variable    
     208   &  cn_varfile        !< input file and mask variable 
    209209 
    210210   NAMELIST /namout/ &  !< output namelist 
     
    212212   &  in_njproc,     & 
    213213   &  in_nproc 
    214    !-------------------------------------------------------------------    
     214   !------------------------------------------------------------------- 
    215215 
    216216   ! 
     
    224224   IF( il_narg /= 1 )THEN 
    225225      WRITE(cl_errormsg,*) ' ERROR : one argument is needed ' 
    226       CALL fct_help(cp_myname,cl_errormsg)  
     226      CALL fct_help(cp_myname,cl_errormsg) 
    227227      CALL EXIT(1) 
    228228   ELSE 
     
    259259               IF( il_status /= 0 )THEN 
    260260                  WRITE(cl_errormsg,*) " ERROR : error opening "//TRIM(cl_namelist) 
    261                   CALL fct_help(cp_myname,cl_errormsg)  
     261                  CALL fct_help(cp_myname,cl_errormsg) 
    262262                  CALL EXIT(1) 
    263263               ENDIF 
     
    298298 
    299299               WRITE(cl_errormsg,*) " ERROR : can't find "//TRIM(cl_namelist) 
    300                CALL fct_help(cp_myname,cl_errormsg)  
     300               CALL fct_help(cp_myname,cl_errormsg) 
    301301               CALL EXIT(1) 
    302302 
     
    314314 
    315315      CALL multi_print(tl_multi) 
    316        
     316 
    317317      ! open file 
    318318      tl_file=file_init(TRIM(tl_multi%t_mpp(1)%c_name)) 
  • utils/tools/SIREN/src/create_meshmask.f90

    r12080 r13369  
    1414!> @section sec1 method 
    1515!>  bathymetry (and optionally ice shelf draft) is read on input file.<br/> 
    16 !>  horizontal grid-point position, scale factors, and the coriolis factor  
    17 !>  are read in coordinates file or computed.<br/>  
     16!>  horizontal grid-point position, scale factors, and the coriolis factor 
     17!>  are read in coordinates file or computed.<br/> 
    1818!>  vertical coordinate is defined, and the bathymetry recomputed to fit the 
    1919!>  vertical grid.<br/> 
     
    2222!>  all the variables read and or computed, are writen in one to three file(s) depending on 
    2323!>  output option. 
    24 !>  @note  
     24!>  @note 
    2525!>    the file contain depends on 
    2626!>    the vertical coordinate used (z-coord, partial steps, s-coord) 
     
    6060!> 
    6161!>    here after, each sub-namelist parameters is detailed. 
    62 !>    @note  
     62!>    @note 
    6363!>       default values are specified between brackets 
    6464!> 
     
    7979!>          - none 
    8080!> 
    81 !>    - **in_maxerror** [@a 5]<br/>  
     81!>    - **in_maxerror** [@a 5]<br/> 
    8282!>       maximum number of error allowed 
    8383!> 
     
    8787!>    - **cn_varcfg** [@a ./cfg/variable.cfg]<br/> 
    8888!>       path to the variable configuration file.<br/> 
    89 !>       the variable configuration file defines standard name,  
    90 !>       default interpolation method, axis,...  
    91 !>       to be used for some known variables.<br/>  
    92 !> 
    93 !>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/>  
    94 !>       path to the dimension configuration file.<br/>  
    95 !>       the dimension configuration file defines dimensions allowed.<br/>  
    96 !> 
    97 !>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/>  
     89!>       the variable configuration file defines standard name, 
     90!>       default interpolation method, axis,... 
     91!>       to be used for some known variables.<br/> 
     92!> 
     93!>    - **cn_dimcfg** [@a ./cfg/dimension.cfg]<br/> 
     94!>       path to the dimension configuration file.<br/> 
     95!>       the dimension configuration file defines dimensions allowed.<br/> 
     96!> 
     97!>    - **cn_dumcfg** [@a ./cfg/dummy.cfg]<br/> 
    9898!>       path to the useless (dummy) configuration file.<br/> 
    99 !>       the dummy configuration file defines useless  
     99!>       the dummy configuration file defines useless 
    100100!>       dimension or variable. these dimension(s) or variable(s) will not be 
    101101!>       processed.<br/> 
    102102!> 
    103 !> @subsection subsrc namsrc  
     103!> @subsection subsrc namsrc 
    104104!>    the source grid sub-namelist parameters are : 
    105105!> 
     
    204204!>       double tanh function parameter 
    205205!> 
    206 !>     @note  
     206!>     @note 
    207207!>       If *dn_ppa1*, *dn_ppa0* and *dn_ppsur* are undefined, 
    208208!>       NEMO will compute them from *dn_ppdzmin, dn_pphmax, dn_ppkth, dn_ppacr* 
     
    266266!>       lateral boundary conditions at the coast (modify fmask) 
    267267!>       -     shlat = 0 : free slip 
    268 !>       - 0 < shlat < 2 : partial slip  
     268!>       - 0 < shlat < 2 : partial slip 
    269269!>       -     shlat = 2 : no slip 
    270270!>       -     shlat > 2 : strong slip 
    271271!> 
    272 !>    for more information see Boundary Condition at the Coast  
     272!>    for more information see Boundary Condition at the Coast 
    273273!>    in [NEMO documentation](https://forge.ipsl.jussieu.fr/nemo/chrome/site/doc/NEMO/manual/pdf/NEMO_manual.pdf) 
    274274!> 
     
    312312!>       - if niproc, and njproc are provided : the program only look for land 
    313313!>         processor to be removed 
    314 !>       - if nproc is provided : the program compute each possible domain layout,  
    315 !>         and save the one with the most land processor to be removed  
     314!>       - if nproc is provided : the program compute each possible domain layout, 
     315!>         and save the one with the most land processor to be removed 
    316316!>       - with no information about number of processors, the program 
    317317!>         assume to use only one processor 
     
    326326!>    @note 
    327327!>        - if 0 < in_msh <= 3: write full 3D arrays for e3[tuvw] and gdep[tuvw] 
    328 !>        - if 3 < in_msh <= 6: write full 3D arrays for e3[tuvw] and 2D arrays  
     328!>        - if 3 < in_msh <= 6: write full 3D arrays for e3[tuvw] and 2D arrays 
    329329!>                            corresponding to the depth of the bottom t- and w-points 
    330330!>        - if 6 < in_msh <= 9: write 2D arrays corresponding to the depth and the 
     
    405405 
    406406   TYPE(TDIM)                                     :: tl_dim 
    407     
     407 
    408408   TYPE(TVAR)                                     :: tl_bathy 
    409409   TYPE(TVAR)                                     :: tl_risfdep 
     
    438438   ! namelist variable 
    439439   ! namlog 
    440    CHARACTER(LEN=lc) :: cn_logfile  = 'create_meshmask.log'  
    441    CHARACTER(LEN=lc) :: cn_verbosity= 'warning'  
     440   CHARACTER(LEN=lc) :: cn_logfile  = 'create_meshmask.log' 
     441   CHARACTER(LEN=lc) :: cn_verbosity= 'warning' 
    442442   INTEGER(i4)       :: in_maxerror = 5 
    443443 
    444444   ! namcfg 
    445    CHARACTER(LEN=lc) :: cn_varcfg   = './cfg/variable.cfg'  
     445   CHARACTER(LEN=lc) :: cn_varcfg   = './cfg/variable.cfg' 
    446446   CHARACTER(LEN=lc) :: cn_dimcfg   = './cfg/dimension.cfg' 
    447447   CHARACTER(LEN=lc) :: cn_dumcfg   = './cfg/dummy.cfg' 
     
    470470   ! namout 
    471471   CHARACTER(LEN=lc) :: cn_domcfg   = 'domain_cfg.nc' 
    472    INTEGER(i4)       :: in_msh      = 0  
     472   INTEGER(i4)       :: in_msh      = 0 
    473473   CHARACTER(LEN=lc) :: cn_type     = 'cdf' 
    474474   INTEGER(i4)       :: in_nproc    = 0 
     
    513513   &  in_niproc,     &  !< i-direction number of processor 
    514514   &  in_njproc         !< j-direction numebr of processor 
    515    !-------------------------------------------------------------------    
     515   !------------------------------------------------------------------- 
    516516 
    517517   ! 
     
    525525   IF( il_narg /= 1 )THEN 
    526526      WRITE(cl_errormsg,*) ' ERROR : one argument is needed ' 
    527       CALL fct_help(cp_myname,cl_errormsg)  
     527      CALL fct_help(cp_myname,cl_errormsg) 
    528528      CALL EXIT(1) 
    529529   ELSE 
     
    560560               IF( il_status /= 0 )THEN 
    561561                  WRITE(cl_errormsg,*) " ERROR : error opening "//TRIM(cl_namelist) 
    562                   CALL fct_help(cp_myname,cl_errormsg)  
     562                  CALL fct_help(cp_myname,cl_errormsg) 
    563563                  CALL EXIT(1) 
    564564               ENDIF 
    565565 
    566566               READ( il_fileid, NML = namlog ) 
    567   
     567 
    568568               ! define logger file 
    569569               CALL logger_open(TRIM(cn_logfile),TRIM(cn_verbosity),in_maxerror) 
     
    599599 
    600600               WRITE(cl_errormsg,*) " ERROR : can't find "//TRIM(cl_namelist) 
    601                CALL fct_help(cp_myname,cl_errormsg)  
     601               CALL fct_help(cp_myname,cl_errormsg) 
    602602               CALL EXIT(1) 
    603603 
     
    618618   ELSE 
    619619      CALL logger_fatal("CREATE MESH MASK: no input bathymetry file found. "//& 
    620       &     "check namelist")       
     620      &     "check namelist") 
    621621   ENDIF 
    622622 
     
    652652      tl_bathy%d_value(:,:,1,1) = 0._dp 
    653653   END WHERE 
    654   
     654 
    655655   IF ( ln_isfcav ) THEN 
    656656      WRITE(*,*) 'ICESHELF DRAFT FILE TO BE USED:',TRIM(cn_isfdep) 
     
    662662      ELSE 
    663663         CALL logger_fatal("CREATE MESH MASK: no input Iceshelf draft '//& 
    664             &  'file found. check namelist")       
     664            &  'file found. check namelist") 
    665665      ENDIF 
    666666 
     
    709709   ! compute horizontal mesh 
    710710   WRITE(*,*) "COMPUTE HORIZONTAL MESH" 
    711    CALL grid_hgr_fill(tl_namh,jpi,jpj,ll_domcfg)       
     711   CALL grid_hgr_fill(tl_namh,jpi,jpj,ll_domcfg) 
    712712 
    713713   ! Vertyical  mesh (dom_zgr) ------------------------------------------------- 
     
    717717   CALL grid_zgr_init(jpi,jpj,jpk,ln_sco) 
    718718   IF( ln_zps    ) CALL grid_zgr_zps_init(jpi,jpj) 
    719    IF( ln_sco    ) CALL grid_zgr_sco_init(jpi,jpj)  
     719   IF( ln_sco    ) CALL grid_zgr_sco_init(jpi,jpj) 
    720720 
    721721   ! compute vertical  mesh 
     
    729729   ! Maximum stiffness ratio/hydrostatic consistency 
    730730   IF( ln_sco    ) CALL grid_zgr_sco_stiff(tl_namz,jpi,jpj,jpk) 
    731   
     731 
    732732   ! clean 
    733733   CALL var_clean(tl_bathy) 
    734734 
    735735   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
    736    ! create ouptut structure  
     736   ! create ouptut structure 
    737737   IF( in_niproc == 0 .AND. & 
    738738   &   in_njproc == 0 .AND. & 
     
    768768         tl_mpphgr=>tl_mppout0 
    769769         tl_mppzgr=>tl_mppout0 
    770           
     770 
    771771         !                                  ! ============================ 
    772       CASE ( 2 )                            !  create 'mesh.nc' and  
     772      CASE ( 2 )                            !  create 'mesh.nc' and 
    773773         !                                  !         'mask.nc' files 
    774774         !                                  ! ============================ 
     
    823823      tl_scalar=var_init('jpkglo', il_tmp(:), id_type=NF90_INT, td_dim=tl_dim) 
    824824      CALL mpp_add_var(tl_mppmsk, tl_scalar) 
    825        
     825 
    826826      il_tmp(:)=tl_mppout0%i_perio 
    827827      tl_scalar=var_init('jperio', il_tmp(:), id_type=NF90_INT, td_dim=tl_dim) 
     
    953953      CALL mpp_add_var(tl_mpphgr, tg_gcosf) 
    954954      CALL var_clean(tg_gcosf) 
    955        
     955 
    956956      ! sint 
    957957      CALL mpp_add_var(tl_mpphgr, tg_gsint) 
     
    967967      CALL var_clean(tg_gsinf) 
    968968   ENDIF 
    969     
     969 
    970970   !!! vertical mesh (zgr) 
    971971   !!!---------------------- 
    972972   ! note that mbkt is set to 1 over land ==> use surface tmask 
    973    !  
     973   ! 
    974974   ! mbathy 
    975975   tg_mbathy%d_value(:,:,:,:) = tg_ssmask%d_value(:,:,:,:) * & 
     
    10001000      tl_risfdep%d_value(:,:,:,:) = tl_risfdep%d_value(:,:,:,:) * & 
    10011001      &                             tg_mikt%d_value(:,:,:,:) 
    1002   
     1002 
    10031003      CALL mpp_add_var(tl_mppzgr, tl_risfdep) 
    10041004      CALL var_clean(tl_risfdep) 
     
    10781078         CALL mpp_add_var(tl_mppzgr, tg_gdepw_1d) 
    10791079         CALL var_clean(tg_gdepw_1d) 
    1080           
     1080 
    10811081         ! gdept_0 
    1082          CALL mpp_add_var(tl_mppzgr, tg_gdept_0)       
     1082         CALL mpp_add_var(tl_mppzgr, tg_gdept_0) 
    10831083         CALL var_clean(tg_gdept_0) 
    10841084         ! gdepw_0 
    1085          CALL mpp_add_var(tl_mppzgr, tg_gdepw_0)       
     1085         CALL mpp_add_var(tl_mppzgr, tg_gdepw_0) 
    10861086         CALL var_clean(tg_gdepw_0) 
    10871087      ENDIF 
     
    11081108      ELSE 
    11091109 
    1110          DO jj = 1,jpj    
     1110         DO jj = 1,jpj 
    11111111            DO ji = 1,jpi 
    11121112               ik=tg_mbkt%d_value(ji,jj,1,1) 
     
    11161116                  &                         tg_ssmask%d_value(ji,jj,1,1) 
    11171117            END DO 
    1118          END DO          
     1118         END DO 
    11191119         ! e3t_ps 
    11201120         CALL mpp_add_var(tl_mppzgr, tg_e3tp) 
     
    11271127 
    11281128      IF( ll_domcfg .OR. in_msh <= 3 ) THEN ! 3D depth 
    1129           
     1129 
    11301130         IF( .NOT. tl_namz%l_e3_dep )THEN 
    1131        
     1131 
    11321132            ! gdepu, gdepv 
    11331133            IF( .NOT. ll_domcfg )THEN 
     
    11391139 
    11401140               DEALLOCATE(dl_tmp3D) 
    1141                DO jk = 1,jpk    
    1142                   DO jj = 1, jpj-1    
     1141               DO jk = 1,jpk 
     1142                  DO jj = 1, jpj-1 
    11431143                     DO ji = 1, jpi-1   ! vector opt. 
    11441144                        tl_gdepu%d_value(ji,jj,jk,1) = MIN( tg_gdept_0%d_value(ji  ,jj  ,jk,1) , & 
     
    11471147                        tl_gdepv%d_value(ji,jj,jk,1) = MIN( tg_gdept_0%d_value(ji  ,jj  ,jk,1) , & 
    11481148                           &                                tg_gdept_0%d_value(ji  ,jj+1,jk,1) ) 
    1149                      END DO    
    1150                   END DO    
    1151                END DO          
     1149                     END DO 
     1150                  END DO 
     1151               END DO 
    11521152               CALL lbc_lnk( tl_gdepu%d_value(:,:,:,1), 'U', in_perio, 1._dp ) 
    11531153               CALL lbc_lnk( tl_gdepv%d_value(:,:,:,1), 'V', in_perio, 1._dp ) 
     
    11781178 
    11791179         DEALLOCATE(dl_tmp2D) 
    1180          DO jj = 1,jpj    
     1180         DO jj = 1,jpj 
    11811181            DO ji = 1,jpi 
    11821182               ik=tg_mbkt%d_value(ji,jj,1,1) 
     
    12091209   ENDIF 
    12101210 
    1211    IF( ln_zps .OR. ln_zco )THEN ! z-coordinate  
     1211   IF( ln_zps .OR. ln_zco )THEN ! z-coordinate 
    12121212      IF( .NOT. tl_namz%l_e3_dep )THEN 
    12131213         ! depth 
     
    12331233         tl_att=att_init("Created_by","SIREN create_meshmask") 
    12341234         CALL mpp_add_att(tl_mppmsk, tl_att) 
    1235           
     1235 
    12361236         !add source url 
    12371237         cl_url=fct_split(fct_split(cp_url,2,'$'),2,'URL:') 
     
    12431243         tl_att=att_init("Creation_date",TRIM(cl_date)) 
    12441244         CALL mpp_add_att(tl_mppmsk, tl_att) 
    1245           
     1245 
    12461246         ! add attribute periodicity 
    12471247         il_attid=0 
     
    12531253            CALL mpp_add_att(tl_mppmsk,tl_att) 
    12541254         ENDIF 
    1255           
     1255 
    12561256         il_attid=0 
    12571257         IF( ASSOCIATED(tl_mppmsk%t_proc(1)%t_att) )THEN 
     
    12621262            CALL mpp_add_att(tl_mppmsk,tl_att) 
    12631263         ENDIF 
    1264           
     1264 
    12651265         ji=1 
    12661266         DO WHILE( tl_gatt(ji)%c_name /= '' ) 
     
    12711271         ! create file 
    12721272         CALL iom_mpp_create(tl_mppmsk) 
    1273           
     1273 
    12741274         ! write file 
    12751275         CALL iom_mpp_write_file(tl_mppmsk) 
    12761276         ! close file 
    12771277         CALL iom_mpp_close(tl_mppmsk) 
    1278           
     1278 
    12791279         ! clean 
    12801280         CALL mpp_clean(tl_mppmsk) 
     
    12851285         CALL mpp_add_att(tl_mppmsk, tl_att) 
    12861286         CALL mpp_add_att(tl_mpphgr, tl_att) 
    1287           
     1287 
    12881288         !add source url 
    12891289         cl_url=fct_split(fct_split(cp_url,2,'$'),2,'URL:') 
     
    12971297         CALL mpp_add_att(tl_mppmsk, tl_att) 
    12981298         CALL mpp_add_att(tl_mpphgr, tl_att) 
    1299           
     1299 
    13001300         ! add attribute periodicity 
    13011301         il_attid=0 
     
    13081308            CALL mpp_add_att(tl_mpphgr,tl_att) 
    13091309         ENDIF 
    1310           
     1310 
    13111311         il_attid=0 
    13121312         IF( ASSOCIATED(tl_mppmsk%t_proc(1)%t_att) )THEN 
     
    13251325            ji=ji+1 
    13261326         ENDDO 
    1327           
     1327 
    13281328         !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
    13291329         ! create mask file 
    13301330         !----------------- 
    13311331         CALL iom_mpp_create(tl_mppmsk) 
    1332           
     1332 
    13331333         ! write file 
    13341334         CALL iom_mpp_write_file(tl_mppmsk) 
    13351335         ! close file 
    13361336         CALL iom_mpp_close(tl_mppmsk) 
    1337           
     1337 
    13381338         ! clean 
    13391339         CALL mpp_clean(tl_mppmsk) 
     
    13421342         !----------------- 
    13431343         CALL iom_mpp_create(tl_mpphgr) 
    1344           
     1344 
    13451345         ! write file 
    13461346         CALL iom_mpp_write_file(tl_mpphgr) 
    13471347         ! close file 
    13481348         CALL iom_mpp_close(tl_mpphgr) 
    1349           
     1349 
    13501350         ! clean 
    13511351         CALL mpp_clean(tl_mpphgr) 
     
    13571357         CALL mpp_add_att(tl_mpphgr, tl_att) 
    13581358         CALL mpp_add_att(tl_mppzgr, tl_att) 
    1359           
     1359 
    13601360         !add source url 
    13611361         cl_url=fct_split(fct_split(cp_url,2,'$'),2,'URL:') 
     
    13711371         CALL mpp_add_att(tl_mpphgr, tl_att) 
    13721372         CALL mpp_add_att(tl_mppzgr, tl_att) 
    1373           
     1373 
    13741374         ! add attribute periodicity 
    13751375         il_attid=0 
     
    13831383            CALL mpp_add_att(tl_mppzgr,tl_att) 
    13841384         ENDIF 
    1385   
     1385 
    13861386         il_attid=0 
    13871387         IF( ASSOCIATED(tl_mppmsk%t_proc(1)%t_att) )THEN 
     
    14071407         !----------------- 
    14081408         CALL iom_mpp_create(tl_mppmsk) 
    1409   
     1409 
    14101410         ! write file 
    14111411         CALL iom_mpp_write_file(tl_mppmsk) 
    14121412         ! close file 
    14131413         CALL iom_mpp_close(tl_mppmsk) 
    1414   
     1414 
    14151415         ! clean 
    14161416         WRITE(*,*) "CLEAN MSK"