Changeset 7731 for branches/UKMO/dev_r5518_v3.6_asm_nemovar_community/NEMOGCM/TOOLS/SIREN/src/variable.f90
- Timestamp:
- 2017-02-23T14:23:32+01:00 (7 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/UKMO/dev_r5518_v3.6_asm_nemovar_community/NEMOGCM/TOOLS/SIREN/src/variable.f90
r5037 r7731 281 281 !> @date November, 2014 282 282 !> - Fix memory leaks bug 283 !> @date June, 2015 284 !> - change way to get variable information in namelist 285 !> @date July, 2015 286 !> - add subroutine var_chg_unit to change unit of output variable 283 287 ! 284 288 !> @note Software governed by the CeCILL licence (NEMOGCM/NEMO_CeCILL.txt) … … 293 297 USE att ! attribute manager 294 298 USE dim ! dimension manager 299 USE math ! mathematical function 295 300 IMPLICIT NONE 296 301 ! NOTE_avoid_public_variables_if_possible … … 318 323 PUBLIC :: var_concat !< concatenate two variables 319 324 PUBLIC :: var_limit_value !< forced min and max value 325 PUBLIC :: var_chg_unit !< change variable unit and value 320 326 PUBLIC :: var_max_dim !< get array of maximum dimension use 321 327 PUBLIC :: var_reorder !< reorder table of value in variable structure … … 382 388 PRIVATE :: var__get_max ! get maximum value from namelist 383 389 PRIVATE :: var__get_min ! get minimum value from namelist 390 PRIVATE :: var__get_unf ! get scale factor value from namelist 391 PRIVATE :: var__get_unt ! get unit from namelist 384 392 PRIVATE :: var__get_interp ! get interpolation method from namelist 385 393 PRIVATE :: var__get_extrap ! get extrapolation method from namelist … … 401 409 TYPE(TATT), DIMENSION(:), POINTER :: t_att => NULL() !< variable attributes 402 410 TYPE(TDIM), DIMENSION(ip_maxdim) :: t_dim !< variable dimension 403 411 404 412 LOGICAL :: l_file = .FALSE. !< variable read in a file 405 413 … … 414 422 REAL(dp) :: d_min = dp_fill !< minimum value 415 423 REAL(dp) :: d_max = dp_fill !< maximum value 416 424 425 CHARACTER(LEN=lc) :: c_unt = '' !< new variables units (linked to units factor) 426 REAL(dp) :: d_unf = 1._dp !< units factor 427 417 428 !!! netcdf4 418 429 LOGICAL :: l_contiguous = .FALSE. !< use contiguous storage or not … … 518 529 !> 519 530 !> @author J.Paul 520 !> - November, 2013- Initial Version531 !> @date November, 2013 - Initial Version 521 532 !> @date November, 2014 522 533 !> - use function instead of overload assignment operator (to avoid memory leak) … … 548 559 var__copy_unit%d_min = td_var%d_min 549 560 var__copy_unit%d_max = td_var%d_max 561 562 var__copy_unit%c_unt = TRIM(td_var%c_unt) 563 var__copy_unit%d_unf = td_var%d_unf 550 564 551 565 var__copy_unit%i_type = td_var%i_type … … 577 591 var__copy_unit%c_units = TRIM(td_var%c_units) 578 592 var__copy_unit%c_axis = TRIM(td_var%c_axis) 593 var__copy_unit%d_unf = td_var%d_unf 579 594 var__copy_unit%d_scf = td_var%d_scf 580 595 var__copy_unit%d_ofs = td_var%d_ofs … … 627 642 !> 628 643 !> @author J.Paul 629 !> - November, 2013- Initial Version644 !> @date November, 2013 - Initial Version 630 645 !> @date November, 2014 631 646 !> - use function instead of overload assignment operator … … 656 671 !> 657 672 !> @author J.Paul 658 !> - November, 2013- Initial Version673 !> @date November, 2013 - Initial Version 659 674 !> 660 675 !> @param[inout] td_var variable strucutre … … 695 710 ! 696 711 !> @author J.Paul 697 !> - September, 2014- Initial Version712 !> @date September, 2014 - Initial Version 698 713 ! 699 714 !> @param[inout] td_var array of variable strucutre … … 718 733 ! 719 734 !> @author J.Paul 720 !> - September, 2014- Initial Version735 !> @date September, 2014 - Initial Version 721 736 ! 722 737 !> @param[inout] td_var array of variable strucutre … … 744 759 ! 745 760 !> @author J.Paul 746 !> - September, 2014- Initial Version761 !> @date September, 2014 - Initial Version 747 762 ! 748 763 !> @param[inout] td_var array of variable strucutre … … 788 803 !> - id_id : variable id (read from a file). 789 804 !> - id_ew : number of point composing east west wrap band. 805 !> - dd_unf : real(8) value for units factor attribute. 790 806 !> - dd_scf : real(8) value for scale factor attribute. 791 807 !> - dd_ofs : real(8) value for add offset attribute. … … 801 817 !> - cd_extrap : a array of character defining extrapolation method. 802 818 !> - cd_filter : a array of character defining filtering method. 819 !> - cd_unt : a string character to define output unit 820 !> - dd_unf : real(8) factor applied to change unit 803 821 !> 804 822 !> @note most of these optionals arguments will be inform automatically, … … 806 824 !> 807 825 !> @author J.Paul 808 !> - November, 2013- Initial Version 826 !> @date November, 2013 - Initial Version 827 !> @date February, 2015 828 !> - Bug fix: conversion of the FillValue type (float case) 829 !> @date June, 2015 830 !> - add unit factor (to change unit) 809 831 !> 810 832 !> @param[in] cd_name variable name … … 833 855 !> @param[in] cd_extrap extrapolation method 834 856 !> @param[in] cd_filter filter method 857 !> @param[in] cd_unt new units (linked to units factor) 858 !> @param[in] dd_unf units factor 835 859 !> @return variable structure 836 860 !------------------------------------------------------------------- … … 843 867 & ld_contiguous, ld_shuffle,& 844 868 & ld_fletcher32, id_deflvl, id_chunksz, & 845 & cd_interp, cd_extrap, cd_filter ) 869 & cd_interp, cd_extrap, cd_filter, & 870 & cd_unt, dd_unf ) 846 871 IMPLICIT NONE 847 872 ! Argument … … 871 896 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 872 897 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 898 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 899 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 873 900 874 901 … … 933 960 tl_att=att_init('_FillValue', INT(dd_fill,i4) ) 934 961 CASE(NF90_FLOAT) 935 tl_att=att_init('_FillValue', INT(dd_fill,sp) )962 tl_att=att_init('_FillValue', REAL(dd_fill,sp) ) 936 963 CASE DEFAULT ! NF90_DOUBLE 937 964 tl_att=att_init('_FillValue', dd_fill ) 938 965 END SELECT 939 966 CALL var_move_att(var__init, tl_att) … … 1038 1065 ENDIF 1039 1066 1067 ! units factor 1068 IF( PRESENT(dd_unf) )THEN 1069 tl_att=att_init('units_factor',dd_unf) 1070 CALL var_move_att(var__init, tl_att) 1071 ENDIF 1072 1073 ! new units (linked to units factor) 1074 IF( PRESENT(cd_unt) )THEN 1075 tl_att=att_init('new_units',cd_units) 1076 CALL var_move_att(var__init, tl_att) 1077 ENDIF 1078 1040 1079 ! add extra information 1041 1080 CALL var__get_extra(var__init) … … 1047 1086 CALL var_del_att(var__init, 'filter') 1048 1087 CALL var_del_att(var__init, 'src_file') 1088 CALL var_del_att(var__init, 'src_i_indices') 1089 CALL var_del_att(var__init, 'src_j_indices') 1049 1090 CALL var_del_att(var__init, 'valid_min') 1050 1091 CALL var_del_att(var__init, 'valid_max') … … 1072 1113 ! 1073 1114 !> @author J.Paul 1074 !> - November, 2013- Initial Version 1075 ! 1115 !> @date November, 2013 - Initial Version 1116 !> @date June, 2015 1117 !> - add interp, extrap, and filter argument 1118 !> @date July, 2015 1119 !> - add unit factor (to change unit) 1120 !> 1076 1121 !> @param[in] cd_name variable name 1077 1122 !> @param[in] dd_value 1D array of real(8) value … … 1100 1145 !> @param[in] id_deflvl deflate level from 0 to 9, 0 indicates no deflation is in use 1101 1146 !> @param[in] id_chunksz chunk size 1147 !> @param[in] cd_interp interpolation method 1148 !> @param[in] cd_extrap extrapolation method 1149 !> @param[in] cd_filter filter method 1150 !> @param[in] cd_unt new units (linked to units factor) 1151 !> @param[in] dd_unf units factor 1102 1152 !> @return variable structure 1103 1153 !------------------------------------------------------------------- … … 1110 1160 & dd_min, dd_max, & 1111 1161 & ld_contiguous, ld_shuffle,& 1112 & ld_fletcher32, id_deflvl, id_chunksz) 1162 & ld_fletcher32, id_deflvl, id_chunksz, & 1163 & cd_interp, cd_extrap, cd_filter, & 1164 & cd_unt, dd_unf) 1113 1165 IMPLICIT NONE 1114 1166 ! Argument … … 1138 1190 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 1139 1191 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 1192 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 1193 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 1194 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 1195 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 1196 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 1140 1197 1141 1198 ! local variable … … 1193 1250 & ld_fletcher32=ld_fletcher32, & 1194 1251 & id_deflvl=id_deflvl, & 1195 & id_chunksz=id_chunksz(:)) 1252 & id_chunksz=id_chunksz(:), & 1253 & cd_interp=cd_interp(:), & 1254 & cd_extrap=cd_extrap(:), & 1255 & cd_filter=cd_filter(:), & 1256 & cd_unt=cd_unt, dd_unf=dd_unf ) 1196 1257 1197 1258 ! add value … … 1239 1300 ! 1240 1301 !> @author J.Paul 1241 !> - November, 2013- Initial Version 1302 !> @date November, 2013 - Initial Version 1303 !> @date February, 2015 1304 !> - bug fix: array initialise with dimension 1305 !> array not only one value 1306 !> @date June, 2015 1307 !> - add interp, extrap, and filter argument 1308 !> - Bux fix: dimension array initialise not only one value 1309 !> @date July, 2015 1310 !> - add unit factor (to change unit) 1242 1311 ! 1243 1312 !> @param[in] cd_name variable name … … 1269 1338 !> no deflation is in use 1270 1339 !> @param[in] id_chunksz chunk size 1340 !> @param[in] cd_interp interpolation method 1341 !> @param[in] cd_extrap extrapolation method 1342 !> @param[in] cd_filter filter method 1343 !> @param[in] cd_unt new units (linked to units factor) 1344 !> @param[in] dd_unf units factor 1271 1345 !> @return variable structure 1272 1346 !------------------------------------------------------------------- … … 1279 1353 & dd_min, dd_max, & 1280 1354 & ld_contiguous, ld_shuffle,& 1281 & ld_fletcher32, id_deflvl, id_chunksz) 1355 & ld_fletcher32, id_deflvl, id_chunksz, & 1356 & cd_interp, cd_extrap, cd_filter, & 1357 & cd_unt, dd_unf) 1282 1358 IMPLICIT NONE 1283 1359 ! Argument … … 1307 1383 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 1308 1384 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 1385 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 1386 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 1387 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 1388 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 1389 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 1309 1390 1310 1391 ! local variable … … 1350 1431 ENDIF 1351 1432 1352 il_count(:)=tl_dim( 1)%i_len1433 il_count(:)=tl_dim(:)%i_len 1353 1434 IF( PRESENT(id_count) )THEN 1354 1435 IF( SIZE(id_count(:)) /= 2 )THEN … … 1381 1462 & ld_fletcher32=ld_fletcher32, & 1382 1463 & id_deflvl=id_deflvl, & 1383 & id_chunksz=id_chunksz(:)) 1464 & id_chunksz=id_chunksz(:), & 1465 & cd_interp=cd_interp(:), & 1466 & cd_extrap=cd_extrap(:), & 1467 & cd_filter=cd_filter(:), & 1468 & cd_unt=cd_unt, dd_unf=dd_unf ) 1384 1469 1385 1470 ! add value … … 1431 1516 ! 1432 1517 !> @author J.Paul 1433 !> - November, 2013- Initial Version 1434 ! 1518 !> @date November, 2013 - Initial Version 1519 !> @date June, 2015 1520 !> - add interp, extrap, and filter argument 1521 !> @date July, 2015 1522 !> - add unit factor (to change unit) 1523 !> 1435 1524 !> @param[in] cd_name variable name 1436 1525 !> @param[in] dd_value 1D array of real(8) value … … 1461 1550 !> deflation is in use 1462 1551 !> @param[in] id_chunksz chunk size 1552 !> @param[in] cd_interp interpolation method 1553 !> @param[in] cd_extrap extrapolation method 1554 !> @param[in] cd_filter filter method 1555 !> @param[in] cd_unt new units (linked to units factor) 1556 !> @param[in] dd_unf units factor 1463 1557 !> @return variable structure 1464 1558 !------------------------------------------------------------------- … … 1471 1565 & dd_min, dd_max, & 1472 1566 & ld_contiguous, ld_shuffle,& 1473 & ld_fletcher32, id_deflvl, id_chunksz) 1567 & ld_fletcher32, id_deflvl, id_chunksz, & 1568 & cd_interp, cd_extrap, cd_filter, & 1569 & cd_unt, dd_unf) 1474 1570 IMPLICIT NONE 1475 1571 ! Argument … … 1499 1595 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 1500 1596 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 1597 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 1598 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 1599 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 1600 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 1601 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 1501 1602 1502 1603 ! local variable … … 1577 1678 & ld_fletcher32=ld_fletcher32, & 1578 1679 & id_deflvl=id_deflvl, & 1579 & id_chunksz=id_chunksz(:)) 1680 & id_chunksz=id_chunksz(:), & 1681 & cd_interp=cd_interp(:), & 1682 & cd_extrap=cd_extrap(:), & 1683 & cd_filter=cd_filter(:), & 1684 & cd_unt=cd_unt, dd_unf=dd_unf ) 1580 1685 1581 1686 ! add value … … 1623 1728 ! 1624 1729 !> @author J.Paul 1625 !> - November, 2013- Initial Version 1626 ! 1730 !> @date November, 2013 - Initial Version 1731 !> @date June, 2015 1732 !> - add interp, extrap, and filter argument 1733 !> @date July, 2015 1734 !> - add unit factor (to change unit) 1735 !> 1627 1736 !> @param[in] cd_name variable name 1628 1737 !> @param[in] dd_value 4D array of real(8) value … … 1653 1762 !> deflation is in use 1654 1763 !> @param[in] id_chunksz chunk size 1764 !> @param[in] cd_interp interpolation method 1765 !> @param[in] cd_extrap extrapolation method 1766 !> @param[in] cd_filter filter method 1767 !> @param[in] cd_unt new units (linked to units factor) 1768 !> @param[in] dd_unf units factor 1655 1769 !> @return variable structure 1656 1770 !------------------------------------------------------------------- … … 1663 1777 & dd_min, dd_max, & 1664 1778 & ld_contiguous, ld_shuffle,& 1665 & ld_fletcher32, id_deflvl, id_chunksz) 1779 & ld_fletcher32, id_deflvl, id_chunksz, & 1780 & cd_interp, cd_extrap, cd_filter, & 1781 & cd_unt, dd_unf ) 1666 1782 IMPLICIT NONE 1667 1783 ! Argument … … 1691 1807 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 1692 1808 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 1809 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 1810 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 1811 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 1812 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 1813 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 1693 1814 1694 1815 ! local variable … … 1723 1844 & ld_fletcher32=ld_fletcher32, & 1724 1845 & id_deflvl=id_deflvl, & 1725 & id_chunksz=id_chunksz(:)) 1846 & id_chunksz=id_chunksz(:), & 1847 & cd_interp=cd_interp(:), & 1848 & cd_extrap=cd_extrap(:), & 1849 & cd_filter=cd_filter(:), & 1850 & cd_unt=cd_unt, dd_unf=dd_unf ) 1726 1851 1727 1852 ! add value … … 1758 1883 ! 1759 1884 !> @author J.Paul 1760 !> - November, 2013- Initial Version 1885 !> @date November, 2013 - Initial Version 1886 !> @date June, 2015 1887 !> - add interp, extrap, and filter argument 1888 !> @date July, 2015 1889 !> - add unit factor (to change unit) 1761 1890 ! 1762 1891 !> @param[in] cd_name variable name … … 1788 1917 !> deflation is in use 1789 1918 !> @param[in] id_chunksz chunk size 1919 !> @param[in] cd_interp interpolation method 1920 !> @param[in] cd_extrap extrapolation method 1921 !> @param[in] cd_filter filter method 1922 !> @param[in] cd_unt new units (linked to units factor) 1923 !> @param[in] dd_unf units factor 1790 1924 !> @return variable structure 1791 1925 !------------------------------------------------------------------- … … 1798 1932 & dd_min, dd_max, & 1799 1933 & ld_contiguous, ld_shuffle,& 1800 & ld_fletcher32, id_deflvl, id_chunksz) 1934 & ld_fletcher32, id_deflvl, id_chunksz, & 1935 & cd_interp, cd_extrap, cd_filter, & 1936 & cd_unt, dd_unf) 1801 1937 1802 1938 IMPLICIT NONE … … 1827 1963 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 1828 1964 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 1965 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 1966 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 1967 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 1968 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 1969 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 1970 1829 1971 1830 1972 ! local variable … … 1870 2012 & ld_fletcher32=ld_fletcher32, & 1871 2013 & id_deflvl=id_deflvl, & 1872 & id_chunksz=id_chunksz(:)) 2014 & id_chunksz=id_chunksz(:), & 2015 & cd_interp=cd_interp(:), & 2016 & cd_extrap=cd_extrap(:), & 2017 & cd_filter=cd_filter(:), & 2018 & cd_unt=cd_unt, dd_unf=dd_unf ) 1873 2019 1874 2020 DEALLOCATE( dl_value ) … … 1892 2038 ! 1893 2039 !> @author J.Paul 1894 !> - November, 2013- Initial Version 2040 !> @date November, 2013 - Initial Version 2041 !> @date June, 2015 2042 !> - add interp, extrap, and filter argument 2043 !> @date July, 2015 2044 !> - add unit factor (to change unit) 1895 2045 ! 1896 2046 !> @param[in] cd_name : variable name … … 1922 2072 !> deflation is in use 1923 2073 !> @param[in] id_chunksz : chunk size 2074 !> @param[in] cd_interp interpolation method 2075 !> @param[in] cd_extrap extrapolation method 2076 !> @param[in] cd_filter filter method 2077 !> @param[in] cd_unt new units (linked to units factor) 2078 !> @param[in] dd_unf units factor 1924 2079 !> @return variable structure 1925 2080 !------------------------------------------------------------------- … … 1932 2087 & dd_min, dd_max, & 1933 2088 & ld_contiguous, ld_shuffle,& 1934 & ld_fletcher32, id_deflvl, id_chunksz) 2089 & ld_fletcher32, id_deflvl, id_chunksz, & 2090 & cd_interp, cd_extrap, cd_filter, & 2091 & cd_unt, dd_unf) 1935 2092 1936 2093 IMPLICIT NONE … … 1961 2118 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 1962 2119 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 2120 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 2121 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 2122 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 2123 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 2124 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 1963 2125 1964 2126 ! local variable … … 2006 2168 & ld_fletcher32=ld_fletcher32, & 2007 2169 & id_deflvl=id_deflvl, & 2008 & id_chunksz=id_chunksz(:)) 2170 & id_chunksz=id_chunksz(:), & 2171 & cd_interp=cd_interp(:), & 2172 & cd_extrap=cd_extrap(:), & 2173 & cd_filter=cd_filter(:), & 2174 & cd_unt=cd_unt, dd_unf=dd_unf ) 2009 2175 2010 2176 DEALLOCATE( dl_value ) … … 2028 2194 ! 2029 2195 !> @author J.Paul 2030 !> - November, 2013- Initial Version 2196 !> @date November, 2013 - Initial Version 2197 !> @date June, 2015 2198 !> - add interp, extrap, and filter argument 2199 !> @date July, 2015 2200 !> - add unit factor (to change unit) 2031 2201 ! 2032 2202 !> @param[in] cd_name : variable name … … 2058 2228 !> deflation is in use 2059 2229 !> @param[in] id_chunksz : chunk size 2230 !> @param[in] cd_interp interpolation method 2231 !> @param[in] cd_extrap extrapolation method 2232 !> @param[in] cd_filter filter method 2233 !> @param[in] cd_unt new units (linked to units factor) 2234 !> @param[in] dd_unf units factor 2060 2235 !> @return variable structure 2061 2236 !------------------------------------------------------------------- … … 2068 2243 & dd_min, dd_max, & 2069 2244 & ld_contiguous, ld_shuffle,& 2070 & ld_fletcher32, id_deflvl, id_chunksz) 2245 & ld_fletcher32, id_deflvl, id_chunksz, & 2246 & cd_interp, cd_extrap, cd_filter, & 2247 & cd_unt, dd_unf) 2071 2248 2072 2249 IMPLICIT NONE … … 2097 2274 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 2098 2275 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 2276 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 2277 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 2278 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 2279 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 2280 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 2099 2281 2100 2282 ! local variable … … 2143 2325 & ld_fletcher32=ld_fletcher32, & 2144 2326 & id_deflvl=id_deflvl, & 2145 & id_chunksz=id_chunksz(:)) 2327 & id_chunksz=id_chunksz(:), & 2328 & cd_interp=cd_interp(:), & 2329 & cd_extrap=cd_extrap(:), & 2330 & cd_filter=cd_filter(:), & 2331 & cd_unt=cd_unt, dd_unf=dd_unf) 2146 2332 2147 2333 DEALLOCATE( dl_value ) … … 2165 2351 ! 2166 2352 !> @author J.Paul 2167 !> - November, 2013- Initial Version 2353 !> @date November, 2013 - Initial Version 2354 !> @date June, 2015 2355 !> - add interp, extrap, and filter argument 2356 !> @date July, 2015 2357 !> - add unit factor (to change unit) 2168 2358 ! 2169 2359 !> @param[in] cd_name variable name … … 2195 2385 !> deflation is in use 2196 2386 !> @param[in] id_chunksz chunk size 2387 !> @param[in] cd_interp interpolation method 2388 !> @param[in] cd_extrap extrapolation method 2389 !> @param[in] cd_filter filter method 2390 !> @param[in] cd_unt new units (linked to units factor) 2391 !> @param[in] dd_unf units factor 2197 2392 !> @return variable structure 2198 2393 !------------------------------------------------------------------- … … 2205 2400 & dd_min, dd_max, & 2206 2401 & ld_contiguous, ld_shuffle,& 2207 & ld_fletcher32, id_deflvl, id_chunksz) 2402 & ld_fletcher32, id_deflvl, id_chunksz, & 2403 & cd_interp, cd_extrap, cd_filter, & 2404 & cd_unt, dd_unf) 2208 2405 2209 2406 IMPLICIT NONE … … 2234 2431 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 2235 2432 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 2433 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 2434 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 2435 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 2436 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 2437 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 2236 2438 2237 2439 ! local variable … … 2281 2483 & ld_fletcher32=ld_fletcher32, & 2282 2484 & id_deflvl=id_deflvl, & 2283 & id_chunksz=id_chunksz(:)) 2485 & id_chunksz=id_chunksz(:), & 2486 & cd_interp=cd_interp(:), & 2487 & cd_extrap=cd_extrap(:), & 2488 & cd_filter=cd_filter(:), & 2489 & cd_unt=cd_unt, dd_unf=dd_unf) 2284 2490 2285 2491 DEALLOCATE( dl_value ) … … 2303 2509 ! 2304 2510 !> @author J.Paul 2305 !> - November, 2013- Initial Version 2511 !> @date November, 2013 - Initial Version 2512 !> @date June, 2015 2513 !> - add interp, extrap, and filter argument 2514 !> @date July, 2015 2515 !> - add unit factor (to change unit) 2306 2516 ! 2307 2517 !> @param[in] cd_name : variable name … … 2333 2543 !> deflation is in use 2334 2544 !> @param[in] id_chunksz : chunk size 2545 !> @param[in] cd_interp interpolation method 2546 !> @param[in] cd_extrap extrapolation method 2547 !> @param[in] cd_filter filter method 2548 !> @param[in] cd_unt new units (linked to units factor) 2549 !> @param[in] dd_unf units factor 2335 2550 !> @return variable structure 2336 2551 !------------------------------------------------------------------- … … 2343 2558 & dd_min, dd_max, & 2344 2559 & ld_contiguous, ld_shuffle,& 2345 & ld_fletcher32, id_deflvl, id_chunksz) 2560 & ld_fletcher32, id_deflvl, id_chunksz, & 2561 & cd_interp, cd_extrap, cd_filter, & 2562 & cd_unt, dd_unf) 2346 2563 2347 2564 IMPLICIT NONE … … 2372 2589 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 2373 2590 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 2591 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 2592 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 2593 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 2594 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 2595 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 2374 2596 2375 2597 ! local variable … … 2415 2637 & ld_fletcher32=ld_fletcher32, & 2416 2638 & id_deflvl=id_deflvl, & 2417 & id_chunksz=id_chunksz(:)) 2639 & id_chunksz=id_chunksz(:), & 2640 & cd_interp=cd_interp(:), & 2641 & cd_extrap=cd_extrap(:), & 2642 & cd_filter=cd_filter(:), & 2643 & cd_unt=cd_unt, dd_unf=dd_unf) 2418 2644 2419 2645 DEALLOCATE( dl_value ) … … 2437 2663 ! 2438 2664 !> @author J.Paul 2439 !> - November, 2013- Initial Version 2665 !> @date November, 2013 - Initial Version 2666 !> @date June, 2015 2667 !> - add interp, extrap, and filter argument 2668 !> @date July, 2015 2669 !> - add unit factor (to change unit) 2440 2670 ! 2441 2671 !> @param[in] cd_name variable name … … 2465 2695 !> @param[in] id_deflvl deflate level from 0 to 9, 0 indicates no deflation is in use 2466 2696 !> @param[in] id_chunksz chunk size 2697 !> @param[in] cd_interp interpolation method 2698 !> @param[in] cd_extrap extrapolation method 2699 !> @param[in] cd_filter filter method 2700 !> @param[in] cd_unt new units (linked to units factor) 2701 !> @param[in] dd_unf units factor 2467 2702 !> @return variable structure 2468 2703 !------------------------------------------------------------------- … … 2475 2710 & dd_min, dd_max, & 2476 2711 & ld_contiguous, ld_shuffle,& 2477 & ld_fletcher32, id_deflvl, id_chunksz) 2712 & ld_fletcher32, id_deflvl, id_chunksz, & 2713 & cd_interp, cd_extrap, cd_filter, & 2714 & cd_unt, dd_unf) 2478 2715 2479 2716 IMPLICIT NONE … … 2504 2741 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 2505 2742 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 2743 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 2744 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 2745 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 2746 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 2747 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 2506 2748 2507 2749 ! local variable … … 2549 2791 & ld_fletcher32=ld_fletcher32, & 2550 2792 & id_deflvl=id_deflvl, & 2551 & id_chunksz=id_chunksz(:)) 2793 & id_chunksz=id_chunksz(:), & 2794 & cd_interp=cd_interp(:), & 2795 & cd_extrap=cd_extrap(:), & 2796 & cd_filter=cd_filter(:), & 2797 & cd_unt=cd_unt, dd_unf=dd_unf) 2552 2798 2553 2799 DEALLOCATE( dl_value ) … … 2571 2817 ! 2572 2818 !> @author J.Paul 2573 !> - November, 2013- Initial Version 2819 !> @date November, 2013 - Initial Version 2820 !> @date June, 2015 2821 !> - add interp, extrap, and filter argument 2822 !> @date July, 2015 2823 !> - add unit factor (to change unit) 2574 2824 ! 2575 2825 !> @param[in] cd_name variable name … … 2601 2851 !> deflation is in use 2602 2852 !> @param[in] id_chunksz chunk size 2853 !> @param[in] cd_interp interpolation method 2854 !> @param[in] cd_extrap extrapolation method 2855 !> @param[in] cd_filter filter method 2856 !> @param[in] cd_unt new units (linked to units factor) 2857 !> @param[in] dd_unf units factor 2603 2858 !> @return variable structure 2604 2859 !------------------------------------------------------------------- … … 2611 2866 & dd_min, dd_max, & 2612 2867 & ld_contiguous, ld_shuffle,& 2613 & ld_fletcher32, id_deflvl, id_chunksz) 2868 & ld_fletcher32, id_deflvl, id_chunksz, & 2869 & cd_interp, cd_extrap, cd_filter, & 2870 & cd_unt, dd_unf) 2614 2871 2615 2872 IMPLICIT NONE … … 2640 2897 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 2641 2898 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 2899 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 2900 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 2901 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 2902 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 2903 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 2642 2904 2643 2905 ! local variable … … 2686 2948 & ld_fletcher32=ld_fletcher32, & 2687 2949 & id_deflvl=id_deflvl, & 2688 & id_chunksz=id_chunksz(:)) 2950 & id_chunksz=id_chunksz(:), & 2951 & cd_interp=cd_interp(:), & 2952 & cd_extrap=cd_extrap(:), & 2953 & cd_filter=cd_filter(:), & 2954 & cd_unt=cd_unt, dd_unf=dd_unf) 2689 2955 2690 2956 DEALLOCATE( dl_value ) … … 2708 2974 ! 2709 2975 !> @author J.Paul 2710 !> - November, 2013- Initial Version 2976 !> @date November, 2013 - Initial Version 2977 !> @date June, 2015 2978 !> - add interp, extrap, and filter argument 2979 !> @date July, 2015 2980 !> - add unit factor (to change unit) 2711 2981 ! 2712 2982 !> @param[in] cd_name variable name … … 2738 3008 !> deflation is in use 2739 3009 !> @param[in] id_chunksz chunk size 3010 !> @param[in] cd_interp interpolation method 3011 !> @param[in] cd_extrap extrapolation method 3012 !> @param[in] cd_filter filter method 3013 !> @param[in] cd_unt new units (linked to units factor) 3014 !> @param[in] dd_unf units factor 2740 3015 !> @return variable structure 2741 3016 !------------------------------------------------------------------- … … 2748 3023 & dd_min, dd_max, & 2749 3024 & ld_contiguous, ld_shuffle,& 2750 & ld_fletcher32, id_deflvl, id_chunksz) 3025 & ld_fletcher32, id_deflvl, id_chunksz, & 3026 & cd_interp, cd_extrap, cd_filter, & 3027 & cd_unt, dd_unf) 2751 3028 2752 3029 IMPLICIT NONE … … 2777 3054 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 2778 3055 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 3056 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 3057 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 3058 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 3059 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 3060 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 3061 2779 3062 2780 3063 ! local variable … … 2824 3107 & ld_fletcher32=ld_fletcher32, & 2825 3108 & id_deflvl=id_deflvl, & 2826 & id_chunksz=id_chunksz(:)) 3109 & id_chunksz=id_chunksz(:), & 3110 & cd_interp=cd_interp(:), & 3111 & cd_extrap=cd_extrap(:), & 3112 & cd_filter=cd_filter(:), & 3113 & cd_unt=cd_unt, dd_unf=dd_unf) 2827 3114 2828 3115 DEALLOCATE( dl_value ) … … 2846 3133 ! 2847 3134 !> @author J.Paul 2848 !> - November, 2013- Initial Version 3135 !> @date November, 2013 - Initial Version 3136 !> @date June, 2015 3137 !> - add interp, extrap, and filter argument 3138 !> @date July, 2015 3139 !> - add unit factor (to change unit) 2849 3140 ! 2850 3141 !> @param[in] cd_name variable name … … 2876 3167 !> deflation is in use 2877 3168 !> @param[in] id_chunksz chunk size 3169 !> @param[in] cd_interp interpolation method 3170 !> @param[in] cd_extrap extrapolation method 3171 !> @param[in] cd_filter filter method 3172 !> @param[in] cd_unt new units (linked to units factor) 3173 !> @param[in] dd_unf units factor 2878 3174 !> @return variable structure 2879 3175 !------------------------------------------------------------------- … … 2886 3182 & dd_min, dd_max, & 2887 3183 & ld_contiguous, ld_shuffle,& 2888 & ld_fletcher32, id_deflvl, id_chunksz) 3184 & ld_fletcher32, id_deflvl, id_chunksz, & 3185 & cd_interp, cd_extrap, cd_filter, & 3186 & cd_unt, dd_unf) 2889 3187 2890 3188 IMPLICIT NONE … … 2915 3213 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 2916 3214 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 3215 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 3216 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 3217 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 3218 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 3219 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 2917 3220 2918 3221 ! local variable … … 2958 3261 & ld_fletcher32=ld_fletcher32, & 2959 3262 & id_deflvl=id_deflvl, & 2960 & id_chunksz=id_chunksz(:)) 3263 & id_chunksz=id_chunksz(:), & 3264 & cd_interp=cd_interp(:), & 3265 & cd_extrap=cd_extrap(:), & 3266 & cd_filter=cd_filter(:), & 3267 & cd_unt=cd_unt, dd_unf=dd_unf) 2961 3268 2962 3269 DEALLOCATE( dl_value ) … … 2980 3287 ! 2981 3288 !> @author J.Paul 2982 !> - November, 2013- Initial Version 3289 !> @date November, 2013 - Initial Version 3290 !> @date June, 2015 3291 !> - add interp, extrap, and filter argument 3292 !> @date July, 2015 3293 !> - add unit factor (to change unit) 2983 3294 ! 2984 3295 !> @param[in] cd_name variable name … … 3010 3321 !> deflation is in use 3011 3322 !> @param[in] id_chunksz chunk size 3323 !> @param[in] cd_interp interpolation method 3324 !> @param[in] cd_extrap extrapolation method 3325 !> @param[in] cd_filter filter method 3326 !> @param[in] cd_unt new units (linked to units factor) 3327 !> @param[in] dd_unf units factor 3012 3328 !> @return variable structure 3013 3329 !------------------------------------------------------------------- … … 3020 3336 & dd_min, dd_max, & 3021 3337 & ld_contiguous, ld_shuffle,& 3022 & ld_fletcher32, id_deflvl, id_chunksz) 3338 & ld_fletcher32, id_deflvl, id_chunksz, & 3339 & cd_interp, cd_extrap, cd_filter, & 3340 & cd_unt, dd_unf) 3023 3341 3024 3342 IMPLICIT NONE … … 3049 3367 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 3050 3368 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 3369 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 3370 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 3371 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 3372 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 3373 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 3051 3374 3052 3375 ! local variable … … 3094 3417 & ld_fletcher32=ld_fletcher32, & 3095 3418 & id_deflvl=id_deflvl, & 3096 & id_chunksz=id_chunksz(:)) 3419 & id_chunksz=id_chunksz(:), & 3420 & cd_interp=cd_interp(:), & 3421 & cd_extrap=cd_extrap(:), & 3422 & cd_filter=cd_filter(:), & 3423 & cd_unt=cd_unt, dd_unf=dd_unf) 3097 3424 3098 3425 DEALLOCATE( dl_value ) … … 3116 3443 ! 3117 3444 !> @author J.Paul 3118 !> - November, 2013- Initial Version 3445 !> @date November, 2013 - Initial Version 3446 !> @date June, 2015 3447 !> - add interp, extrap, and filter argument 3448 !> @date July, 2015 3449 !> - add unit factor (to change unit) 3119 3450 ! 3120 3451 !> @param[in] cd_name variable name … … 3146 3477 !> deflation is in use 3147 3478 !> @param[in] id_chunksz chunk size 3479 !> @param[in] cd_interp interpolation method 3480 !> @param[in] cd_extrap extrapolation method 3481 !> @param[in] cd_filter filter method 3482 !> @param[in] cd_unt new units (linked to units factor) 3483 !> @param[in] dd_unf units factor 3148 3484 !> @return variable structure 3149 3485 !------------------------------------------------------------------- … … 3156 3492 & dd_min, dd_max, & 3157 3493 & ld_contiguous, ld_shuffle,& 3158 & ld_fletcher32, id_deflvl, id_chunksz) 3494 & ld_fletcher32, id_deflvl, id_chunksz, & 3495 & cd_interp, cd_extrap, cd_filter, & 3496 & cd_unt, dd_unf) 3159 3497 3160 3498 IMPLICIT NONE … … 3185 3523 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 3186 3524 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 3525 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 3526 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 3527 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 3528 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 3529 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 3187 3530 3188 3531 ! local variable … … 3231 3574 & ld_fletcher32=ld_fletcher32, & 3232 3575 & id_deflvl=id_deflvl, & 3233 & id_chunksz=id_chunksz(:)) 3576 & id_chunksz=id_chunksz(:), & 3577 & cd_interp=cd_interp(:), & 3578 & cd_extrap=cd_extrap(:), & 3579 & cd_filter=cd_filter(:), & 3580 & cd_unt=cd_unt, dd_unf=dd_unf) 3234 3581 3235 3582 DEALLOCATE( dl_value ) … … 3253 3600 ! 3254 3601 !> @author J.Paul 3255 !> - November, 2013- Initial Version 3602 !> @date November, 2013 - Initial Version 3603 !> @date June, 2015 3604 !> - add interp, extrap, and filter argument 3605 !> @date July, 2015 3606 !> - add unit factor (to change unit) 3256 3607 ! 3257 3608 !> @param[in] cd_name variable name … … 3283 3634 !> deflation is in use 3284 3635 !> @param[in] id_chunksz chunk size 3636 !> @param[in] cd_interp interpolation method 3637 !> @param[in] cd_extrap extrapolation method 3638 !> @param[in] cd_filter filter method 3639 !> @param[in] cd_unt new units (linked to units factor) 3640 !> @param[in] dd_unf units factor 3641 3285 3642 !> @return variable structure 3286 3643 !------------------------------------------------------------------- … … 3293 3650 & dd_min, dd_max, & 3294 3651 & ld_contiguous, ld_shuffle,& 3295 & ld_fletcher32, id_deflvl, id_chunksz) 3652 & ld_fletcher32, id_deflvl, id_chunksz, & 3653 & cd_interp, cd_extrap, cd_filter, & 3654 & cd_unt, dd_unf) 3296 3655 3297 3656 IMPLICIT NONE … … 3322 3681 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 3323 3682 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 3683 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 3684 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 3685 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 3686 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 3687 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 3324 3688 3325 3689 ! local variable … … 3369 3733 & ld_fletcher32=ld_fletcher32, & 3370 3734 & id_deflvl=id_deflvl, & 3371 & id_chunksz=id_chunksz(:)) 3735 & id_chunksz=id_chunksz(:), & 3736 & cd_interp=cd_interp(:), & 3737 & cd_extrap=cd_extrap(:), & 3738 & cd_filter=cd_filter(:), & 3739 & cd_unt=cd_unt, dd_unf=dd_unf) 3372 3740 3373 3741 DEALLOCATE( dl_value ) … … 3391 3759 ! 3392 3760 !> @author J.Paul 3393 !> - November, 2013- Initial Version 3761 !> @date November, 2013 - Initial Version 3762 !> @date June, 2015 3763 !> - add interp, extrap, and filter argument 3764 !> @date July, 2015 3765 !> - add unit factor (to change unit) 3394 3766 ! 3395 3767 !> @param[in] cd_name variable name … … 3421 3793 !> deflation is in use 3422 3794 !> @param[in] id_chunksz chunk size 3795 !> @param[in] cd_interp interpolation method 3796 !> @param[in] cd_extrap extrapolation method 3797 !> @param[in] cd_filter filter method 3798 !> @param[in] cd_unt new units (linked to units factor) 3799 !> @param[in] dd_unf units factor 3423 3800 !> @return variable structure 3424 3801 !------------------------------------------------------------------- … … 3431 3808 & dd_min, dd_max, & 3432 3809 & ld_contiguous, ld_shuffle,& 3433 & ld_fletcher32, id_deflvl, id_chunksz) 3810 & ld_fletcher32, id_deflvl, id_chunksz, & 3811 & cd_interp, cd_extrap, cd_filter, & 3812 & cd_unt, dd_unf) 3434 3813 3435 3814 IMPLICIT NONE … … 3460 3839 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 3461 3840 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 3841 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 3842 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 3843 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 3844 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 3845 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 3846 3462 3847 3463 3848 ! local variable … … 3503 3888 & ld_fletcher32=ld_fletcher32, & 3504 3889 & id_deflvl=id_deflvl, & 3505 & id_chunksz=id_chunksz(:)) 3890 & id_chunksz=id_chunksz(:), & 3891 & cd_interp=cd_interp(:), & 3892 & cd_extrap=cd_extrap(:), & 3893 & cd_filter=cd_filter(:), & 3894 & cd_unt=cd_unt, dd_unf=dd_unf) 3506 3895 3507 3896 DEALLOCATE( dl_value ) … … 3525 3914 ! 3526 3915 !> @author J.Paul 3527 !> - November, 2013- Initial Version 3916 !> @date November, 2013 - Initial Version 3917 !> @date June, 2015 3918 !> - add interp, extrap, and filter argument 3919 !> @date July, 2015 3920 !> - add unit factor (to change unit) 3528 3921 ! 3529 3922 !> @param[in] cd_name variable name … … 3555 3948 !> deflation is in use 3556 3949 !> @param[in] id_chunksz chunk size 3950 !> @param[in] cd_interp interpolation method 3951 !> @param[in] cd_extrap extrapolation method 3952 !> @param[in] cd_filter filter method 3953 !> @param[in] cd_unt new units (linked to units factor) 3954 !> @param[in] dd_unf units factor 3557 3955 !> @return variable structure 3558 3956 !------------------------------------------------------------------- … … 3565 3963 & dd_min, dd_max, & 3566 3964 & ld_contiguous, ld_shuffle,& 3567 & ld_fletcher32, id_deflvl, id_chunksz) 3965 & ld_fletcher32, id_deflvl, id_chunksz, & 3966 & cd_interp, cd_extrap, cd_filter, & 3967 & cd_unt, dd_unf) 3568 3968 3569 3969 IMPLICIT NONE … … 3594 3994 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 3595 3995 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 3996 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 3997 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 3998 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 3999 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 4000 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 4001 3596 4002 3597 4003 ! local variable … … 3639 4045 & ld_fletcher32=ld_fletcher32, & 3640 4046 & id_deflvl=id_deflvl, & 3641 & id_chunksz=id_chunksz(:)) 4047 & id_chunksz=id_chunksz(:), & 4048 & cd_interp=cd_interp(:), & 4049 & cd_extrap=cd_extrap(:), & 4050 & cd_filter=cd_filter(:), & 4051 & cd_unt=cd_unt, dd_unf=dd_unf) 3642 4052 3643 4053 DEALLOCATE( dl_value ) … … 3661 4071 ! 3662 4072 !> @author J.Paul 3663 !> - November, 2013- Initial Version 4073 !> @date November, 2013 - Initial Version 4074 !> @date June, 2015 4075 !> - add interp, extrap, and filter argument 4076 !> @date July, 2015 4077 !> - add unit factor (to change unit) 3664 4078 ! 3665 4079 !> @param[in] cd_name variable name … … 3691 4105 !> deflation is in use 3692 4106 !> @param[in] id_chunksz chunk size 4107 !> @param[in] cd_interp interpolation method 4108 !> @param[in] cd_extrap extrapolation method 4109 !> @param[in] cd_filter filter method 4110 !> @param[in] cd_unt new units (linked to units factor) 4111 !> @param[in] dd_unf units factor 3693 4112 !> @return variable structure 3694 4113 !------------------------------------------------------------------- … … 3701 4120 & dd_min, dd_max, & 3702 4121 & ld_contiguous, ld_shuffle,& 3703 & ld_fletcher32, id_deflvl, id_chunksz) 4122 & ld_fletcher32, id_deflvl, id_chunksz, & 4123 & cd_interp, cd_extrap, cd_filter, & 4124 & cd_unt, dd_unf) 3704 4125 3705 4126 IMPLICIT NONE … … 3730 4151 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 3731 4152 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 4153 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 4154 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 4155 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 4156 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 4157 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 3732 4158 3733 4159 ! local variable … … 3776 4202 & ld_fletcher32=ld_fletcher32, & 3777 4203 & id_deflvl=id_deflvl, & 3778 & id_chunksz=id_chunksz(:)) 4204 & id_chunksz=id_chunksz(:), & 4205 & cd_interp=cd_interp(:), & 4206 & cd_extrap=cd_extrap(:), & 4207 & cd_filter=cd_filter(:), & 4208 & cd_unt=cd_unt, dd_unf=dd_unf) 3779 4209 3780 4210 DEALLOCATE( dl_value ) … … 3798 4228 ! 3799 4229 !> @author J.Paul 3800 !> - November, 2013- Initial Version 4230 !> @date November, 2013 - Initial Version 4231 !> @date June, 2015 4232 !> - add interp, extrap, and filter argument 4233 !> @date July, 2015 4234 !> - add unit factor (to change unit) 3801 4235 ! 3802 4236 !> @param[in] cd_name variable name … … 3828 4262 !> deflation is in use 3829 4263 !> @param[in] id_chunksz chunk size 4264 !> @param[in] cd_interp interpolation method 4265 !> @param[in] cd_extrap extrapolation method 4266 !> @param[in] cd_filter filter method 4267 !> @param[in] cd_unt new units (linked to units factor) 4268 !> @param[in] dd_unf units factor 3830 4269 !> @return variable structure 3831 4270 !------------------------------------------------------------------- … … 3838 4277 & dd_min, dd_max, & 3839 4278 & ld_contiguous, ld_shuffle,& 3840 & ld_fletcher32, id_deflvl, id_chunksz) 4279 & ld_fletcher32, id_deflvl, id_chunksz, & 4280 & cd_interp, cd_extrap, cd_filter, & 4281 & cd_unt, dd_unf) 3841 4282 3842 4283 IMPLICIT NONE … … 3867 4308 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 3868 4309 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 4310 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 4311 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 4312 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 4313 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 4314 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 3869 4315 3870 4316 ! local variable … … 3914 4360 & ld_fletcher32=ld_fletcher32, & 3915 4361 & id_deflvl=id_deflvl, & 3916 & id_chunksz=id_chunksz(:)) 4362 & id_chunksz=id_chunksz(:), & 4363 & cd_interp=cd_interp(:), & 4364 & cd_extrap=cd_extrap(:), & 4365 & cd_filter=cd_filter(:), & 4366 & cd_unt=cd_unt, dd_unf=dd_unf) 3917 4367 3918 4368 DEALLOCATE( dl_value ) … … 3936 4386 ! 3937 4387 !> @author J.Paul 3938 !> - November, 2013- Initial Version 4388 !> @date November, 2013 - Initial Version 4389 !> @date June, 2015 4390 !> - add interp, extrap, and filter argument 4391 !> @date July, 2015 4392 !> - add unit factor (to change unit) 3939 4393 ! 3940 4394 !> @param[in] cd_name variable name … … 3966 4420 !> deflation is in use 3967 4421 !> @param[in] id_chunksz chunk size 4422 !> @param[in] cd_interp interpolation method 4423 !> @param[in] cd_extrap extrapolation method 4424 !> @param[in] cd_filter filter method 4425 !> @param[in] cd_unt new units (linked to units factor) 4426 !> @param[in] dd_unf units factor 3968 4427 !> @return variable structure 3969 4428 !------------------------------------------------------------------- … … 3976 4435 & dd_min, dd_max, & 3977 4436 & ld_contiguous, ld_shuffle,& 3978 & ld_fletcher32, id_deflvl, id_chunksz) 4437 & ld_fletcher32, id_deflvl, id_chunksz, & 4438 & cd_interp, cd_extrap, cd_filter, & 4439 & cd_unt, dd_unf) 3979 4440 3980 4441 IMPLICIT NONE … … 4005 4466 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 4006 4467 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 4468 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 4469 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 4470 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 4471 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 4472 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 4007 4473 4008 4474 ! local variable … … 4048 4514 & ld_fletcher32=ld_fletcher32, & 4049 4515 & id_deflvl=id_deflvl, & 4050 & id_chunksz=id_chunksz(:)) 4516 & id_chunksz=id_chunksz(:), & 4517 & cd_interp=cd_interp(:), & 4518 & cd_extrap=cd_extrap(:), & 4519 & cd_filter=cd_filter(:), & 4520 & cd_unt=cd_unt, dd_unf=dd_unf) 4051 4521 4052 4522 DEALLOCATE( dl_value ) … … 4070 4540 ! 4071 4541 !> @author J.Paul 4072 !> - November, 2013- Initial Version 4542 !> @date November, 2013 - Initial Version 4543 !> @date June, 2015 4544 !> - add interp, extrap, and filter argument 4545 !> @date July, 2015 4546 !> - add unit factor (to change unit) 4073 4547 ! 4074 4548 !> @param[in] cd_name variable name … … 4100 4574 !> deflation is in use 4101 4575 !> @param[in] id_chunksz chunk size 4576 !> @param[in] cd_interp interpolation method 4577 !> @param[in] cd_extrap extrapolation method 4578 !> @param[in] cd_filter filter method 4579 !> @param[in] cd_unt new units (linked to units factor) 4580 !> @param[in] dd_unf units factor 4102 4581 !> @return variable structure 4103 4582 !------------------------------------------------------------------- … … 4110 4589 & dd_min, dd_max, & 4111 4590 & ld_contiguous, ld_shuffle,& 4112 & ld_fletcher32, id_deflvl, id_chunksz) 4591 & ld_fletcher32, id_deflvl, id_chunksz, & 4592 & cd_interp, cd_extrap, cd_filter, & 4593 & cd_unt, dd_unf) 4113 4594 4114 4595 IMPLICIT NONE … … 4139 4620 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 4140 4621 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 4622 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 4623 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 4624 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 4625 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 4626 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 4141 4627 4142 4628 ! local variable … … 4184 4670 & ld_fletcher32=ld_fletcher32, & 4185 4671 & id_deflvl=id_deflvl, & 4186 & id_chunksz=id_chunksz(:)) 4672 & id_chunksz=id_chunksz(:), & 4673 & cd_interp=cd_interp(:), & 4674 & cd_extrap=cd_extrap(:), & 4675 & cd_filter=cd_filter(:), & 4676 & cd_unt=cd_unt, dd_unf=dd_unf) 4187 4677 4188 4678 DEALLOCATE( dl_value ) … … 4206 4696 ! 4207 4697 !> @author J.Paul 4208 !> - November, 2013- Initial Version 4698 !> @date November, 2013 - Initial Version 4699 !> @date June, 2015 4700 !> - add interp, extrap, and filter argument 4701 !> @date July, 2015 4702 !> - add unit factor (to change unit) 4209 4703 ! 4210 4704 !> @param[in] cd_name variable name … … 4236 4730 !> deflation is in use 4237 4731 !> @param[in] id_chunksz chunk size 4732 !> @param[in] cd_interp interpolation method 4733 !> @param[in] cd_extrap extrapolation method 4734 !> @param[in] cd_filter filter method 4735 !> @param[in] cd_unt new units (linked to units factor) 4736 !> @param[in] dd_unf units factor 4238 4737 !> @return variable structure 4239 4738 !------------------------------------------------------------------- … … 4246 4745 & dd_min, dd_max, & 4247 4746 & ld_contiguous, ld_shuffle,& 4248 & ld_fletcher32, id_deflvl, id_chunksz) 4747 & ld_fletcher32, id_deflvl, id_chunksz, & 4748 & cd_interp, cd_extrap, cd_filter, & 4749 & cd_unt, dd_unf) 4249 4750 4250 4751 IMPLICIT NONE … … 4275 4776 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 4276 4777 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 4778 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 4779 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 4780 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 4781 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 4782 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 4277 4783 4278 4784 ! local variable … … 4321 4827 & ld_fletcher32=ld_fletcher32, & 4322 4828 & id_deflvl=id_deflvl, & 4323 & id_chunksz=id_chunksz(:)) 4829 & id_chunksz=id_chunksz(:), & 4830 & cd_interp=cd_interp(:), & 4831 & cd_extrap=cd_extrap(:), & 4832 & cd_filter=cd_filter(:), & 4833 & cd_unt=cd_unt, dd_unf=dd_unf) 4324 4834 4325 4835 DEALLOCATE( dl_value ) … … 4343 4853 ! 4344 4854 !> @author J.Paul 4345 !> - November, 2013- Initial Version 4855 !> @date November, 2013 - Initial Version 4856 !> @date June, 2015 4857 !> - add interp, extrap, and filter argument 4858 !> @date July, 2015 4859 !> - add unit factor (to change unit) 4346 4860 ! 4347 4861 !> @param[in] cd_name variable name … … 4373 4887 !> deflation is in use 4374 4888 !> @param[in] id_chunksz chunk size 4889 !> @param[in] cd_interp interpolation method 4890 !> @param[in] cd_extrap extrapolation method 4891 !> @param[in] cd_filter filter method 4892 !> @param[in] cd_unt new units (linked to units factor) 4893 !> @param[in] dd_unf units factor 4375 4894 !> @return variable structure 4376 4895 !------------------------------------------------------------------- … … 4383 4902 & dd_min, dd_max, & 4384 4903 & ld_contiguous, ld_shuffle,& 4385 & ld_fletcher32, id_deflvl, id_chunksz) 4904 & ld_fletcher32, id_deflvl, id_chunksz, & 4905 & cd_interp, cd_extrap, cd_filter, & 4906 & cd_unt, dd_unf) 4386 4907 4387 4908 IMPLICIT NONE … … 4412 4933 INTEGER(i4) , INTENT(IN), OPTIONAL :: id_deflvl 4413 4934 INTEGER(i4) , DIMENSION(ip_maxdim), INTENT(IN), OPTIONAL :: id_chunksz 4935 CHARACTER(LEN=*), DIMENSION(2) , INTENT(IN), OPTIONAL :: cd_interp 4936 CHARACTER(LEN=*), DIMENSION(1) , INTENT(IN), OPTIONAL :: cd_extrap 4937 CHARACTER(LEN=*), DIMENSION(5) , INTENT(IN), OPTIONAL :: cd_filter 4938 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_unt 4939 REAL(dp) , INTENT(IN), OPTIONAL :: dd_unf 4414 4940 4415 4941 ! local variable … … 4459 4985 & ld_fletcher32=ld_fletcher32, & 4460 4986 & id_deflvl=id_deflvl, & 4461 & id_chunksz=id_chunksz(:)) 4987 & id_chunksz=id_chunksz(:), & 4988 & cd_interp=cd_interp(:), & 4989 & cd_extrap=cd_extrap(:), & 4990 & cd_filter=cd_filter(:), & 4991 & cd_unt=cd_unt, dd_unf=dd_unf) 4462 4992 4463 4993 DEALLOCATE( dl_value ) … … 4473 5003 !> 4474 5004 !> @author J.Paul 4475 !> - November, 2013- Initial Version5005 !> @date November, 2013 - Initial Version 4476 5006 ! 4477 5007 !> @param[in] td_var1 variable structure … … 4523 5053 !> 4524 5054 !> @author J.Paul 4525 !> - November, 2013- Initial Version5055 !> @date November, 2013 - Initial Version 4526 5056 ! 4527 5057 !> @param[in] td_var1 variable structure … … 4595 5125 !> 4596 5126 !> @author J.Paul 4597 !> - November, 2013- Initial Version5127 !> @date November, 2013 - Initial Version 4598 5128 ! 4599 5129 !> @param[in] td_var1 variable structure … … 4670 5200 !> 4671 5201 !> @author J.Paul 4672 !> - November, 2013- Initial Version5202 !> @date November, 2013 - Initial Version 4673 5203 ! 4674 5204 !> @param[in] td_var1 variable structure … … 4745 5275 !> 4746 5276 !> @author J.Paul 4747 !> - November, 2013- Initial Version5277 !> @date November, 2013 - Initial Version 4748 5278 ! 4749 5279 !> @param[in] td_var1 variable structure … … 4820 5350 !> 4821 5351 !> @author J.Paul 4822 !> - November, 2013- Initial Version 5352 !> @date November, 2013 - Initial Version 5353 !> @date June, 2015 5354 !> - add all element of the array in the same time 4823 5355 !> 4824 5356 !> @param[inout] td_var variable structure … … 4833 5365 ! local variable 4834 5366 INTEGER(i4) :: il_natt 5367 INTEGER(i4) :: il_status 5368 INTEGER(i4) :: il_ind 5369 TYPE(TATT), DIMENSION(:), ALLOCATABLE :: tl_att 4835 5370 4836 5371 ! loop indices … … 4840 5375 il_natt=SIZE(td_att(:)) 4841 5376 5377 IF( td_var%i_natt > 0 )THEN 5378 ! already other attribute in variable structure 5379 ALLOCATE( tl_att(td_var%i_natt), stat=il_status ) 5380 IF(il_status /= 0 )THEN 5381 5382 CALL logger_error( & 5383 & " VAR ADD ATT: not enough space to put attributes from "//& 5384 & TRIM(td_var%c_name)//" in temporary attribute structure") 5385 5386 ELSE 5387 5388 ! save temporary global attribute's variable structure 5389 tl_att(:)=att_copy(td_var%t_att(:)) 5390 5391 CALL att_clean(td_var%t_att(:)) 5392 DEALLOCATE( td_var%t_att ) 5393 ALLOCATE( td_var%t_att(td_var%i_natt+il_natt), stat=il_status ) 5394 IF(il_status /= 0 )THEN 5395 5396 CALL logger_error( & 5397 & " VAR ADD ATT: not enough space to put attributes "//& 5398 & "in variable structure "//TRIM(td_var%c_name) ) 5399 5400 ENDIF 5401 5402 ! copy attribute in variable before 5403 td_var%t_att(1:td_var%i_natt)=att_copy(tl_att(:)) 5404 5405 ! clean 5406 CALL att_clean(tl_att(:)) 5407 DEALLOCATE(tl_att) 5408 5409 ENDIF 5410 ELSE 5411 ! no attribute in variable structure 5412 IF( ASSOCIATED(td_var%t_att) )THEN 5413 CALL att_clean(td_var%t_att(:)) 5414 DEALLOCATE(td_var%t_att) 5415 ENDIF 5416 ALLOCATE( td_var%t_att(td_var%i_natt+il_natt), stat=il_status ) 5417 IF(il_status /= 0 )THEN 5418 5419 CALL logger_error( & 5420 & " VAR ADD ATT: not enough space to put attributes "//& 5421 & "in variable structure "//TRIM(td_var%c_name) ) 5422 5423 ENDIF 5424 ENDIF 5425 5426 ALLOCATE( tl_att(il_natt) ) 5427 tl_att(:)=att_copy(td_att(:)) 5428 5429 ! check if attribute already in variable structure 4842 5430 DO ji=1,il_natt 4843 CALL var_add_att(td_var, td_att(ji)) 5431 il_ind=0 5432 il_ind=att_get_index( td_var%t_att(:), tl_att(ji)%c_name ) 5433 IF( il_ind /= 0 )THEN 5434 CALL logger_error( & 5435 & " VAR ADD ATT: attribute "//TRIM(tl_att(ji)%c_name)//& 5436 & ", already in variable "//TRIM(td_var%c_name) ) 5437 CALL att_clean(tl_att(ji)) 5438 ENDIF 4844 5439 ENDDO 5440 5441 ! add new attributes 5442 td_var%t_att(td_var%i_natt+1:td_var%i_natt+il_natt)=att_copy(tl_att(:)) 5443 5444 DEALLOCATE(tl_att) 5445 5446 DO ji=1,il_natt 5447 ! highlight some attribute 5448 IF( ASSOCIATED(td_var%t_att(td_var%i_natt+ji)%d_value) .OR. & 5449 & td_var%t_att(td_var%i_natt+ji)%c_value /= 'none' )THEN 5450 SELECT CASE(TRIM(td_var%t_att(td_var%i_natt+ji)%c_name)) 5451 5452 CASE("add_offset") 5453 td_var%d_ofs = td_var%t_att(td_var%i_natt+ji)%d_value(1) 5454 CASE("scale_factor") 5455 td_var%d_scf = td_var%t_att(td_var%i_natt+ji)%d_value(1) 5456 CASE("_FillValue") 5457 td_var%d_fill = td_var%t_att(td_var%i_natt+ji)%d_value(1) 5458 CASE("ew_overlap") 5459 td_var%i_ew = INT(td_var%t_att(td_var%i_natt+ji)%d_value(1),i4) 5460 CASE("standard_name") 5461 td_var%c_stdname = TRIM(td_var%t_att(td_var%i_natt+ji)%c_value) 5462 CASE("long_name") 5463 td_var%c_longname = TRIM(td_var%t_att(td_var%i_natt+ji)%c_value) 5464 CASE("units") 5465 td_var%c_units = TRIM(td_var%t_att(td_var%i_natt+ji)%c_value) 5466 CASE("grid_point") 5467 td_var%c_point = TRIM(td_var%t_att(td_var%i_natt+ji)%c_value) 5468 5469 END SELECT 5470 ENDIF 5471 ENDDO 5472 5473 ! update number of attribute 5474 td_var%i_natt=td_var%i_natt+il_natt 5475 4845 5476 4846 5477 END SUBROUTINE var__add_att_arr … … 4850 5481 ! 4851 5482 !> @author J.Paul 4852 !> - November, 2013- Initial Version 5483 !> @date November, 2013 - Initial Version 5484 !> @date June, 2015 5485 !> - use var__add_att_arr subroutine 4853 5486 ! 4854 5487 !> @param[inout] td_var variable structure … … 4862 5495 4863 5496 ! local variable 4864 INTEGER(i4) :: il_status 4865 INTEGER(i4) :: il_ind 4866 TYPE(TATT), DIMENSION(:), ALLOCATABLE :: tl_att 5497 TYPE(TATT), DIMENSION(1) :: tl_att 4867 5498 4868 5499 ! loop indices 4869 INTEGER(i4) :: ji4870 5500 !---------------------------------------------------------------- 4871 5501 4872 ! check if attribute already in variable structure 4873 il_ind=0 4874 IF( ASSOCIATED(td_var%t_att) )THEN 4875 il_ind=att_get_index( td_var%t_att(:), td_att%c_name ) 4876 ENDIF 4877 4878 IF( il_ind /= 0 )THEN 4879 4880 CALL logger_error( & 4881 & " VAR ADD ATT: attribute "//TRIM(td_att%c_name)//& 4882 & ", already in variable "//TRIM(td_var%c_name) ) 4883 4884 DO ji=1,td_var%i_natt 4885 CALL logger_debug( & 4886 & " VAR ADD ATT: in variable "//TRIM(td_var%t_att(ji)%c_name) ) 4887 ENDDO 4888 4889 ELSE 4890 4891 CALL logger_trace( & 4892 & " VAR ADD ATT: add attribute "//TRIM(td_att%c_name)//& 4893 & ", in variable "//TRIM(td_var%c_name) ) 4894 4895 IF( td_var%i_natt > 0 )THEN 4896 ! already other attribute in variable structure 4897 ALLOCATE( tl_att(td_var%i_natt), stat=il_status ) 4898 IF(il_status /= 0 )THEN 4899 4900 CALL logger_error( & 4901 & " VAR ADD ATT: not enough space to put attributes from "//& 4902 & TRIM(td_var%c_name)//" in temporary attribute structure") 4903 4904 ELSE 4905 4906 ! save temporary global attribute's variable structure 4907 tl_att(:)=att_copy(td_var%t_att(:)) 4908 4909 CALL att_clean(td_var%t_att(:)) 4910 DEALLOCATE( td_var%t_att ) 4911 ALLOCATE( td_var%t_att(td_var%i_natt+1), stat=il_status ) 4912 IF(il_status /= 0 )THEN 4913 4914 CALL logger_error( & 4915 & " VAR ADD ATT: not enough space to put attributes "//& 4916 & "in variable structure "//TRIM(td_var%c_name) ) 4917 4918 ENDIF 4919 4920 ! copy attribute in variable before 4921 td_var%t_att(1:td_var%i_natt)=att_copy(tl_att(:)) 4922 4923 ! clean 4924 CALL att_clean(tl_att(:)) 4925 DEALLOCATE(tl_att) 4926 4927 ENDIF 4928 ELSE 4929 ! no attribute in variable structure 4930 IF( ASSOCIATED(td_var%t_att) )THEN 4931 CALL att_clean(td_var%t_att(:)) 4932 DEALLOCATE(td_var%t_att) 4933 ENDIF 4934 ALLOCATE( td_var%t_att(td_var%i_natt+1), stat=il_status ) 4935 IF(il_status /= 0 )THEN 4936 4937 CALL logger_error( & 4938 & " VAR ADD ATT: not enough space to put attributes "//& 4939 & "in variable structure "//TRIM(td_var%c_name) ) 4940 4941 ENDIF 4942 ENDIF 4943 ! update number of attribute 4944 td_var%i_natt=td_var%i_natt+1 4945 4946 ! add new attribute 4947 td_var%t_att(td_var%i_natt)=att_copy(td_att) 4948 4949 !! add new attribute id 4950 !td_var%t_att(td_var%i_natt)%i_id=att_get_unit(td_var%t_att(:)) 4951 4952 ! highlight some attribute 4953 IF( ASSOCIATED(td_var%t_att(td_var%i_natt)%d_value) .OR. & 4954 & td_var%t_att(td_var%i_natt)%c_value /= "none" )THEN 4955 SELECT CASE(TRIM(td_var%t_att(td_var%i_natt)%c_name)) 4956 4957 CASE("add_offset") 4958 td_var%d_ofs = td_var%t_att(td_var%i_natt)%d_value(1) 4959 CASE("scale_factor") 4960 td_var%d_scf = td_var%t_att(td_var%i_natt)%d_value(1) 4961 CASE("_FillValue") 4962 td_var%d_fill = td_var%t_att(td_var%i_natt)%d_value(1) 4963 CASE("ew_overlap") 4964 td_var%i_ew = INT(td_var%t_att(td_var%i_natt)%d_value(1),i4) 4965 CASE("standard_name") 4966 td_var%c_stdname = TRIM(td_var%t_att(td_var%i_natt)%c_value) 4967 CASE("long_name") 4968 td_var%c_longname = TRIM(td_var%t_att(td_var%i_natt)%c_value) 4969 CASE("units") 4970 td_var%c_units = TRIM(td_var%t_att(td_var%i_natt)%c_value) 4971 CASE("grid_point") 4972 td_var%c_point = TRIM(td_var%t_att(td_var%i_natt)%c_value) 4973 4974 END SELECT 4975 ENDIF 4976 ENDIF 5502 ! copy structure in an array 5503 tl_att(1)=att_copy(td_att) 5504 5505 ! 5506 CALL var_add_att( td_var, tl_att(:) ) 4977 5507 4978 5508 END SUBROUTINE var__add_att_unit … … 4982 5512 ! 4983 5513 !> @author J.Paul 4984 !> - November, 2013- Initial Version 5514 !> @date November, 2013 - Initial Version 5515 !> @date February, 2015 5516 !> - define local attribute structure to avoid mistake 5517 !> with pointer 4985 5518 ! 4986 5519 !> @param[inout] td_var variable structure … … 4996 5529 INTEGER(i4) :: il_ind 4997 5530 5531 TYPE(TATT) :: tl_att 4998 5532 ! loop indices 4999 5533 !---------------------------------------------------------------- … … 5007 5541 IF( il_ind == 0 )THEN 5008 5542 5009 CALL logger_ warn( &5543 CALL logger_debug( & 5010 5544 & " VAR DEL ATT: no attribute "//TRIM(cd_name)//& 5011 5545 & ", in variable "//TRIM(td_var%c_name) ) … … 5013 5547 ELSE 5014 5548 5015 CALL var_del_att(td_var, td_var%t_att(il_ind)) 5549 tl_att=att_copy(td_var%t_att(il_ind)) 5550 CALL var_del_att(td_var, tl_att) 5016 5551 5017 5552 ENDIF … … 5023 5558 ! 5024 5559 !> @author J.Paul 5025 !> - November, 2013- Initial Version 5560 !> @date November, 2013- Initial Version 5561 !> @date February, 2015 5562 !> - delete highlight attribute too, when attribute 5563 !> is deleted 5026 5564 ! 5027 5565 !> @param[inout] td_var variable structure … … 5040 5578 5041 5579 ! loop indices 5042 !INTEGER(i4) :: ji5043 5580 !---------------------------------------------------------------- 5044 5581 … … 5051 5588 IF( il_ind == 0 )THEN 5052 5589 5053 CALL logger_ warn( &5590 CALL logger_debug( & 5054 5591 & " VAR DEL ATT: no attribute "//TRIM(td_att%c_name)//& 5055 5592 & ", in variable "//TRIM(td_var%c_name) ) … … 5103 5640 td_var%t_att(1:td_var%i_natt)=att_copy(tl_att(:)) 5104 5641 5105 !! change attribute id5106 !DO ji=1,td_var%i_natt5107 ! td_var%t_att(ji)%i_id=ji5108 !ENDDO5109 5110 5642 ! clean 5111 5643 CALL att_clean(tl_att(:)) … … 5113 5645 ENDIF 5114 5646 ENDIF 5647 5648 ! highlight attribute 5649 SELECT CASE( TRIM(td_att%c_name) ) 5650 5651 CASE("add_offset") 5652 td_var%d_ofs = 0._dp 5653 CASE("scale_factor") 5654 td_var%d_scf = 1._dp 5655 CASE("_FillValue") 5656 td_var%d_fill = 0._dp 5657 CASE("ew_overlap") 5658 td_var%i_ew = -1 5659 CASE("standard_name") 5660 td_var%c_stdname = '' 5661 CASE("long_name") 5662 td_var%c_longname = '' 5663 CASE("units") 5664 td_var%c_units = '' 5665 CASE("grid_point") 5666 td_var%c_point = '' 5667 5668 END SELECT 5669 5115 5670 ENDIF 5116 5671 … … 5121 5676 ! 5122 5677 !> @author J.Paul 5123 !> - November, 2013- Initial Version5678 !> @date November, 2013 - Initial Version 5124 5679 ! 5125 5680 !> @param[inout] td_var variable structure … … 5156 5711 ! 5157 5712 !> @author J.Paul 5158 !> - November, 2013- Initial Version5713 !> @date November, 2013 - Initial Version 5159 5714 ! 5160 5715 !> @param[inout] td_var variable structure … … 5195 5750 ! 5196 5751 !> @author J.Paul 5197 !> - November, 2013- Initial Version5752 !> @date November, 2013 - Initial Version 5198 5753 ! 5199 5754 !> @param[inout] td_var variable structure … … 5211 5766 !---------------------------------------------------------------- 5212 5767 5213 IF( td_var%i_ndim <= 4)THEN5768 IF( td_var%i_ndim <= ip_maxdim )THEN 5214 5769 5215 5770 ! check if dimension already used in variable structure … … 5227 5782 ELSE 5228 5783 5229 ! back to unorder dimension array 5230 CALL dim_unorder(td_var%t_dim(:)) 5784 ! back to disorder dimension array 5785 CALL dim_disorder(td_var%t_dim(:)) 5786 5231 5787 ! add new dimension 5232 5788 td_var%t_dim(td_var%i_ndim+1)=dim_copy(td_dim) … … 5253 5809 ! 5254 5810 !> @author J.Paul 5255 !> - November, 2013- Initial Version5811 !> @date November, 2013 - Initial Version 5256 5812 ! 5257 5813 !> @param[inout] td_var variable structure … … 5272 5828 !---------------------------------------------------------------- 5273 5829 5274 IF( td_var%i_ndim <= 4)THEN5830 IF( td_var%i_ndim <= ip_maxdim )THEN 5275 5831 5276 5832 CALL logger_trace( & … … 5317 5873 ! 5318 5874 !> @author J.Paul 5319 !> - November, 2013- Initial Version5875 !> @date November, 2013 - Initial Version 5320 5876 ! 5321 5877 !> @param[inout] td_var variable structure … … 5360 5916 !> 5361 5917 !> @author J.Paul 5362 !> - June, 2014- Initial Version5918 !> @date June, 2014 - Initial Version 5363 5919 ! 5364 5920 !> @param[in] td_var array of variables structure … … 5386 5942 !> 5387 5943 !> @author J.Paul 5388 !> - November, 2013- Initial Version5944 !> @date November, 2013 - Initial Version 5389 5945 ! 5390 5946 !> @param[in] td_var variable structure … … 5493 6049 !> 5494 6050 !> @author J.Paul 5495 !> - November, 2013- Initial Version6051 !> @date November, 2013 - Initial Version 5496 6052 !> 5497 6053 !> @param[inout] td_var variable structure … … 5631 6187 !> 5632 6188 !> @author J.Paul 5633 !> - November, 2013- Initial Version6189 !> @date November, 2013 - Initial Version 5634 6190 !> 5635 6191 !> @param[inout] td_var variable structure … … 5685 6241 !> 5686 6242 !> @author J.Paul 5687 !> - November, 2013- Initial Version6243 !> @date November, 2013 - Initial Version 5688 6244 ! 5689 6245 !> @param[inout] td_var variable structure … … 5761 6317 ! 5762 6318 !> @author J.Paul 5763 !> - November, 2013- Initial Version6319 !> @date November, 2013 - Initial Version 5764 6320 ! 5765 6321 !> @param[inout] td_var variabele structure … … 5837 6393 ! 5838 6394 !> @author J.Paul 5839 !> - November, 2013- Initial Version6395 !> @date November, 2013 - Initial Version 5840 6396 ! 5841 6397 !> @param[inout] td_var variabele structure … … 5913 6469 ! 5914 6470 !> @author J.Paul 5915 !> - November, 2013- Initial Version6471 !> @date November, 2013 - Initial Version 5916 6472 ! 5917 6473 !> @param[inout] td_var variabele structure … … 5987 6543 !> 5988 6544 !> @author J.Paul 5989 !> - November, 2013- Initial Version6545 !> @date November, 2013 - Initial Version 5990 6546 ! 5991 6547 !> @param[inout] td_var variable structure … … 6057 6613 !> 6058 6614 !> @author J.Paul 6059 !> - November, 2013- Initial Version6615 !> @date November, 2013 - Initial Version 6060 6616 !> 6061 6617 !> @param[inout] td_var variable structure … … 6080 6636 !> 6081 6637 !> @author J.Paul 6082 !> - September, 2014- Initial Version6638 !> @date September, 2014 - Initial Version 6083 6639 !> 6084 6640 !> @param[in] td_var array of variable structure … … 6145 6701 !> 6146 6702 !> @author J.Paul 6147 !> - November, 2013- Initial Version6703 !> @date November, 2013 - Initial Version 6148 6704 ! 6149 6705 !> @param[in] td_var array of variable structure … … 6200 6756 !> 6201 6757 !> @author J.Paul 6202 !> - November, 2013- Initial Version6758 !> @date November, 2013 - Initial Version 6203 6759 ! 6204 6760 !> @param[in] td_var array of variable structure … … 6239 6795 !> 6240 6796 !> @author J.Paul 6241 !> - November, 2013- Initial Version6797 !> @date November, 2013 - Initial Version 6242 6798 ! 6243 6799 !> @param[inout] td_var array of variable structure … … 6322 6878 !> 6323 6879 !> @author J.Paul 6324 !> - November, 2013- Initial Version 6880 !> @date November, 2013 - Initial Version 6881 !> @date June, 2015 6882 !> - new namelist format to get extra information (interpolation,...) 6325 6883 ! 6326 6884 !> @param[in] cd_file configuration file of variable … … 6357 6915 6358 6916 il_fileid=fct_getunit() 6359 CALL logger_trace("VAR DEF EXTRA: open "//TRIM(cd_file))6360 6917 OPEN( il_fileid, FILE=TRIM(cd_file), & 6361 6918 & FORM='FORMATTED', & … … 6366 6923 CALL fct_err(il_status) 6367 6924 IF( il_status /= 0 )THEN 6368 CALL logger_error("VAR DEF EXTRA: opening file "//TRIM(cd_file)) 6925 CALL logger_fatal("VAR DEF EXTRA: can not open file "//& 6926 & TRIM(cd_file)) 6369 6927 ENDIF 6370 6928 … … 6375 6933 DO WHILE( il_status == 0 ) 6376 6934 6377 ! search line donot beginning with comment character6935 ! search line not beginning with comment character 6378 6936 IF( SCAN( TRIM(fct_concat(cp_com(:))) ,cl_line(1:1)) == 0 )THEN 6379 6937 il_nvar=il_nvar+1 … … 6419 6977 tg_varextra(ji)%c_axis =TRIM(fct_split(cl_line,3)) 6420 6978 tg_varextra(ji)%c_point =TRIM(fct_split(cl_line,4)) 6421 tg_varextra(ji)%c_stdname =TRIM(fct_split(cl_line,5)) 6422 tg_varextra(ji)%c_longname=TRIM(fct_split(cl_line,6)) 6423 6424 cl_interp=TRIM(fct_split(cl_line,7)) 6979 6980 cl_interp='int='//TRIM(fct_split(cl_line,5)) 6425 6981 tg_varextra(ji)%c_interp(:) = & 6426 6982 & var__get_interp(TRIM(tg_varextra(ji)%c_name), cl_interp) 6427 6983 CALL logger_debug("VAR DEF EXTRA: "//& 6428 6984 & TRIM(tg_varextra(ji)%c_name)//& 6429 & " "//TRIM(cl_interp)) 6985 & " "//TRIM(tg_varextra(ji)%c_interp(1))) 6986 6987 tg_varextra(ji)%c_longname=TRIM(fct_split(cl_line,6)) 6988 tg_varextra(ji)%c_stdname =TRIM(fct_split(cl_line,7)) 6430 6989 ELSE 6431 6990 ji=ji-1 … … 6458 7017 !> @details 6459 7018 !> string character format must be : <br/> 6460 !> "varname:int erp; filter; extrap; > min; <max"<br/>7019 !> "varname:int=interp; flt=filter; ext=extrap; min=min; max=max"<br/> 6461 7020 !> you could specify only interpolation, filter or extrapolation method, 6462 7021 !> whatever the order. you could find more … … 6464 7023 !> \ref extrap module.<br/> 6465 7024 !> Examples: 6466 !> cn_varinfo='Bathymetry:2*hamming(2,3); > 10.' 6467 !> cn_varinfo='votemper:cubic; dist_weight; <40.' 7025 !> cn_varinfo='Bathymetry:flt=2*hamming(2,3); min=10.' 7026 !> cn_varinfo='votemper:int=cubic; ext=dist_weight; max=40.' 7027 !> 7028 !> 7029 !> @warning variable should be define in tg_varextra (ie in configuration 7030 !> file, to be able to add information from namelist 6468 7031 !> 6469 7032 !> @note If you do not specify a method which is required, default one is … … 6471 7034 !> 6472 7035 !> @author J.Paul 6473 !> - November, 2013- Initial Version 7036 !> @date November, 2013 - Initial Version 7037 !> @date July, 2015 7038 !> - get unit and unit factor (to change unit) 6474 7039 ! 6475 7040 !> @param[in] cd_varinfo variable information from namelist … … 6486 7051 CHARACTER(LEN=lc), DIMENSION(1) :: cl_extrap 6487 7052 CHARACTER(LEN=lc), DIMENSION(5) :: cl_filter 7053 CHARACTER(LEN=lc) :: cl_unt 6488 7054 6489 7055 INTEGER(i4) :: il_ind … … 6492 7058 REAL(dp) :: dl_min 6493 7059 REAL(dp) :: dl_max 7060 REAL(dp) :: dl_unf 6494 7061 6495 7062 TYPE(TVAR) , DIMENSION(:), ALLOCATABLE :: tl_varextra … … 6508 7075 dl_min=var__get_min(cl_name, cl_method) 6509 7076 dl_max=var__get_max(cl_name, cl_method) 7077 dl_unf=var__get_unf(cl_name, cl_method) 6510 7078 cl_interp(:)=var__get_interp(cl_name, cl_method) 6511 7079 cl_extrap(:)=var__get_extrap(cl_name, cl_method) 6512 7080 cl_filter(:)=var__get_filter(cl_name, cl_method) 7081 cl_unt=var__get_unt(cl_name, cl_method) 7082 6513 7083 6514 7084 il_ind=var_get_index(tg_varextra(:), TRIM(cl_name)) … … 6516 7086 IF( dl_min /= dp_fill ) tg_varextra(il_ind)%d_min=dl_min 6517 7087 IF( dl_max /= dp_fill ) tg_varextra(il_ind)%d_max=dl_max 7088 IF( dl_unf /= dp_fill ) tg_varextra(il_ind)%d_unf=dl_unf 7089 IF(cl_unt /='') tg_varextra(il_ind)%c_unt =cl_unt 6518 7090 IF(cl_interp(1)/='') tg_varextra(il_ind)%c_interp(:)=cl_interp(:) 6519 7091 IF(cl_extrap(1)/='') tg_varextra(il_ind)%c_extrap(:)=cl_extrap(:) … … 6551 7123 & cd_filter=cl_filter(:), & 6552 7124 & dd_min = dl_min, & 6553 & dd_max = dl_max ) 7125 & dd_max = dl_max, & 7126 & cd_unt = cl_unt, & 7127 & dd_unf = dl_unf ) 6554 7128 6555 7129 ENDIF 6556 7130 6557 7131 ji=ji+1 6558 CALL logger_ trace( "VAR CHG EXTRA: name "//&7132 CALL logger_debug( "VAR CHG EXTRA: name "//& 6559 7133 & TRIM(tg_varextra(il_ind)%c_name) ) 6560 CALL logger_ trace( "VAR CHG EXTRA: interp "//&7134 CALL logger_debug( "VAR CHG EXTRA: interp "//& 6561 7135 & TRIM(tg_varextra(il_ind)%c_interp(1)) ) 6562 CALL logger_ trace( "VAR CHG EXTRA: filter "//&7136 CALL logger_debug( "VAR CHG EXTRA: filter "//& 6563 7137 & TRIM(tg_varextra(il_ind)%c_filter(1)) ) 6564 CALL logger_ trace( "VAR CHG EXTRA: extrap "//&7138 CALL logger_debug( "VAR CHG EXTRA: extrap "//& 6565 7139 & TRIM(tg_varextra(il_ind)%c_extrap(1)) ) 6566 7140 IF( tg_varextra(il_ind)%d_min /= dp_fill )THEN 6567 CALL logger_ trace( "VAR CHG EXTRA: min value "//&7141 CALL logger_debug( "VAR CHG EXTRA: min value "//& 6568 7142 & TRIM(fct_str(tg_varextra(il_ind)%d_min)) ) 6569 7143 ENDIF 6570 7144 IF( tg_varextra(il_ind)%d_max /= dp_fill )THEN 6571 CALL logger_ trace( "VAR CHG EXTRA: max value "//&7145 CALL logger_debug( "VAR CHG EXTRA: max value "//& 6572 7146 & TRIM(fct_str(tg_varextra(il_ind)%d_max)) ) 7147 ENDIF 7148 IF( TRIM(tg_varextra(il_ind)%c_unt) /= '' )THEN 7149 CALL logger_debug( "VAR CHG EXTRA: new unit "//& 7150 & TRIM(tg_varextra(il_ind)%c_unt) ) 7151 ENDIF 7152 IF( tg_varextra(il_ind)%d_unf /= 1. )THEN 7153 CALL logger_debug( "VAR CHG EXTRA: new unit factor "//& 7154 & TRIM(fct_str(tg_varextra(il_ind)%d_unf)) ) 6573 7155 ENDIF 6574 7156 ENDDO … … 6593 7175 !> 6594 7176 !> @author J.Paul 6595 !> - November, 2013- Initial Version7177 !> @date November, 2013 - Initial Version 6596 7178 ! 6597 7179 !> @param[inout] td_var variable structure … … 6687 7269 !> 6688 7270 !> @author J.Paul 6689 !> - November, 2013- Initial Version7271 !> @date November, 2013 - Initial Version 6690 7272 !> 6691 7273 !> @param[inout] td_var variable structure … … 6808 7390 ENDIF 6809 7391 6810 CALL logger_trace("VAR GET EXTRA: name "//TRIM(td_var%c_name)) 6811 CALL logger_trace("VAR GET EXTRA: stdname "//TRIM(td_var%c_stdname)) 6812 CALL logger_trace("VAR GET EXTRA: longname "//TRIM(td_var%c_longname)) 6813 CALL logger_trace("VAR GET EXTRA: units "//TRIM(td_var%c_units)) 6814 CALL logger_trace("VAR GET EXTRA: point "//TRIM(td_var%c_point)) 6815 CALL logger_trace("VAR GET EXTRA: interp "//TRIM(td_var%c_interp(1))) 6816 CALL logger_trace("VAR GET EXTRA: filter "//TRIM(td_var%c_filter(1))) 6817 CALL logger_trace("VAR GET EXTRA: min value "//TRIM(fct_str(td_var%d_min))) 6818 CALL logger_trace("VAR GET EXTRA: max value "//TRIM(fct_str(td_var%d_max))) 7392 ! unt 7393 IF( TRIM(td_var%c_unt) == '' .AND. & 7394 & TRIM(tg_varextra(il_ind)%c_unt) /= '' )THEN 7395 td_var%c_unt=TRIM(tg_varextra(il_ind)%c_unt) 7396 ENDIF 7397 7398 ! units factor 7399 IF( td_var%d_unf == 1._dp .AND. & 7400 & tg_varextra(il_ind)%d_unf /= 1._dp )THEN 7401 td_var%d_unf=tg_varextra(il_ind)%d_unf 7402 ENDIF 7403 6819 7404 ENDIF 6820 7405 … … 6833 7418 !> 6834 7419 !> @details 6835 !> minimum value is assume to follow s ign '>'7420 !> minimum value is assume to follow string "min =" 6836 7421 !> 6837 7422 !> @author J.Paul 6838 !> - November, 2013- Initial Version 7423 !> @date November, 2013 - Initial Version 7424 !> @date June, 2015 7425 !> - change way to get information in namelist, 7426 !> value follows string "min =" 6839 7427 ! 6840 7428 !> @param[in] cd_name variable name … … 6867 7455 cl_tmp=fct_split(cd_varinfo,ji,';') 6868 7456 DO WHILE( TRIM(cl_tmp) /= '' ) 6869 il_ind= SCAN(TRIM(cl_tmp),'>')7457 il_ind=INDEX(TRIM(cl_tmp),'min') 6870 7458 IF( il_ind /= 0 )THEN 6871 cl_min= TRIM(ADJUSTL(cl_tmp(il_ind+1:)))7459 cl_min=fct_split(cl_tmp,2,'=') 6872 7460 EXIT 6873 7461 ENDIF … … 6877 7465 6878 7466 IF( TRIM(cl_min) /= '' )THEN 6879 IF( fct_is_ num(cl_min) )THEN7467 IF( fct_is_real(cl_min) )THEN 6880 7468 READ(cl_min,*) var__get_min 6881 7469 CALL logger_debug("VAR GET MIN: will use minimum value of "//& … … 6894 7482 !> 6895 7483 !> @details 6896 !> maximum value is assume to follow s ign '<'7484 !> maximum value is assume to follow string "max =" 6897 7485 !> 6898 7486 !> @author J.Paul 6899 !> - November, 2013- Initial Version 7487 !> @date November, 2013 - Initial Version 7488 !> @date June, 2015 7489 !> - change way to get information in namelist, 7490 !> value follows string "max =" 6900 7491 ! 6901 7492 !> @param[in] cd_name variable name … … 6928 7519 cl_tmp=fct_split(cd_varinfo,ji,';') 6929 7520 DO WHILE( TRIM(cl_tmp) /= '' ) 6930 il_ind= SCAN(TRIM(cl_tmp),'<')7521 il_ind=INDEX(TRIM(cl_tmp),'max') 6931 7522 IF( il_ind /= 0 )THEN 6932 cl_max= TRIM(ADJUSTL(cl_tmp(il_ind+1:)))7523 cl_max=fct_split(cl_tmp,2,'=') 6933 7524 EXIT 6934 7525 ENDIF … … 6938 7529 6939 7530 IF( TRIM(cl_max) /= '' )THEN 6940 IF( fct_is_ num(cl_max) )THEN7531 IF( fct_is_real(cl_max) )THEN 6941 7532 READ(cl_max,*) var__get_max 6942 7533 CALL logger_debug("VAR GET MAX: will use maximum value of "//& … … 6952 7543 !> @brief 6953 7544 !> This function check if variable information read in namelist contains 7545 !> units factor value and return it if true. 7546 !> 7547 !> @details 7548 !> units factor value is assume to follow string "unf =" 7549 !> 7550 !> @author J.Paul 7551 !> @date June, 2015 - Initial Version 7552 ! 7553 !> @param[in] cd_name variable name 7554 !> @param[in] cd_varinfo variable information read in namelist 7555 !> @return untis factor value to be used (FillValue if none) 7556 !------------------------------------------------------------------- 7557 FUNCTION var__get_unf( cd_name, cd_varinfo ) 7558 IMPLICIT NONE 7559 ! Argument 7560 CHARACTER(LEN=*), INTENT(IN ) :: cd_name 7561 CHARACTER(LEN=*), INTENT(IN ) :: cd_varinfo 7562 7563 ! function 7564 REAL(dp) :: var__get_unf 7565 7566 ! local variable 7567 CHARACTER(LEN=lc) :: cl_tmp 7568 CHARACTER(LEN=lc) :: cl_unf 7569 7570 INTEGER(i4) :: il_ind 7571 7572 REAL(dp) :: rl_unf 7573 7574 ! loop indices 7575 INTEGER(i4) :: ji 7576 !---------------------------------------------------------------- 7577 ! init 7578 cl_unf='' 7579 var__get_unf=dp_fill 7580 7581 ji=1 7582 cl_tmp=fct_split(cd_varinfo,ji,';') 7583 DO WHILE( TRIM(cl_tmp) /= '' ) 7584 il_ind=INDEX(TRIM(cl_tmp),'unf') 7585 IF( il_ind /= 0 )THEN 7586 cl_unf=fct_split(cl_tmp,2,'=') 7587 EXIT 7588 ENDIF 7589 ji=ji+1 7590 cl_tmp=fct_split(cd_varinfo,ji,';') 7591 ENDDO 7592 7593 IF( TRIM(cl_unf) /= '' )THEN 7594 rl_unf=math_compute(cl_unf) 7595 IF( rl_unf /= dp_fill )THEN 7596 var__get_unf = rl_unf 7597 CALL logger_debug("VAR GET UNITS FACTOR: will use units factor "//& 7598 & "value of "//TRIM(fct_str(var__get_unf))//" for variable "//& 7599 & TRIM(cd_name) ) 7600 ELSE 7601 CALL logger_error("VAR GET UNITS FACTOR: invalid units factor "//& 7602 & "value for variable "//TRIM(cd_name)//". check namelist." ) 7603 ENDIF 7604 ENDIF 7605 7606 END FUNCTION var__get_unf 7607 !------------------------------------------------------------------- 7608 !> @brief 7609 !> This function check if variable information read in namelist contains 6954 7610 !> interpolation method and return it if true. 6955 7611 !> 6956 7612 !> @details 6957 !> split namelist information, using ';' as separator. 7613 !> interpolation method is assume to follow string "int =" 7614 !> 6958 7615 !> compare method name with the list of interpolation method available (see 6959 7616 !> module global). 6960 7617 !> check if factor (*rhoi, /rhoj..) are present.<br/> 6961 7618 !> Example:<br/> 6962 !> - cubic/rhoi ;dist_weight6963 !> - bilin7619 !> - int=cubic/rhoi ; ext=dist_weight 7620 !> - int=bilin 6964 7621 !> see @ref interp module for more information. 6965 7622 !> 6966 7623 !> @author J.Paul 6967 !> - November, 2013- Initial Version 7624 !> @date November, 2013 - Initial Version 7625 !> @date June, 2015 7626 !> - change way to get information in namelist, 7627 !> value follows string "int =" 6968 7628 ! 6969 7629 !> @param[in] cd_name variable name … … 6982 7642 ! local variable 6983 7643 CHARACTER(LEN=lc) :: cl_tmp 7644 CHARACTER(LEN=lc) :: cl_int 6984 7645 CHARACTER(LEN=lc) :: cl_factor 6985 7646 … … 7000 7661 cl_tmp=fct_split(cd_varinfo,ji,';') 7001 7662 DO WHILE( TRIM(cl_tmp) /= '' ) 7663 il_ind=INDEX(TRIM(cl_tmp),'int') 7664 IF( il_ind /= 0 )THEN 7665 cl_int=fct_split(cl_tmp,2,'=') 7666 EXIT 7667 ENDIF 7668 ji=ji+1 7669 cl_tmp=fct_split(cd_varinfo,ji,';') 7670 ENDDO 7671 7672 IF( TRIM(cl_int) /= '' )THEN 7002 7673 DO jj=1,ip_ninterp 7003 il_ind= INDEX(fct_lower(cl_ tmp),TRIM(cp_interp_list(jj)))7674 il_ind= INDEX(fct_lower(cl_int),TRIM(cp_interp_list(jj))) 7004 7675 IF( il_ind /= 0 )THEN 7005 7676 … … 7009 7680 ! look for factor 7010 7681 IF( il_ind==1 )THEN 7011 cl_factor=cl_ tmp(il_len+1:)7682 cl_factor=cl_int(il_len+1:) 7012 7683 ELSE 7013 cl_factor=cl_ tmp(1:il_ind-1)7684 cl_factor=cl_int(1:il_ind-1) 7014 7685 ENDIF 7015 7686 il_mul=SCAN(TRIM(cl_factor),'*') … … 7052 7723 ENDIF 7053 7724 ENDDO 7054 IF( jj /= ip_ninterp + 1 ) EXIT 7055 ji=ji+1 7056 cl_tmp=fct_split(cd_varinfo,ji,';') 7057 ENDDO 7725 ENDIF 7058 7726 7059 7727 END FUNCTION var__get_interp … … 7064 7732 !> 7065 7733 !> @details 7066 !> split namelist information, using ';' as separator. 7734 !> extrapolation method is assume to follow string "ext =" 7735 !> 7067 7736 !> compare method name with the list of extrapolation method available (see 7068 7737 !> module global).<br/> 7069 7738 !> Example:<br/> 7070 !> - cubic ;dist_weight7071 !> - min_error7739 !> - int=cubic ; ext=dist_weight 7740 !> - ext=min_error 7072 7741 !> see @ref extrap module for more information. 7073 7742 !> 7074 7743 !> @author J.Paul 7075 !> - November, 2013- Initial Version 7744 !> @date November, 2013 - Initial Version 7745 !> @date June, 2015 7746 !> - change way to get information in namelist, 7747 !> value follows string "ext =" 7076 7748 ! 7077 7749 !> @param[in] cd_name variable name … … 7090 7762 ! local variable 7091 7763 CHARACTER(LEN=lc) :: cl_tmp 7764 CHARACTER(LEN=lc) :: cl_ext 7765 7766 INTEGER(i4) :: il_ind 7092 7767 7093 7768 ! loop indices … … 7101 7776 cl_tmp=fct_split(cd_varinfo,ji,';') 7102 7777 DO WHILE( TRIM(cl_tmp) /= '' ) 7778 il_ind=INDEX(TRIM(cl_tmp),'ext') 7779 IF( il_ind /= 0 )THEN 7780 cl_ext=fct_split(cl_tmp,2,'=') 7781 EXIT 7782 ENDIF 7783 ji=ji+1 7784 cl_tmp=fct_split(cd_varinfo,ji,';') 7785 ENDDO 7786 7787 IF( TRIM(cl_ext) /= '' )THEN 7103 7788 DO jj=1,ip_nextrap 7104 IF( TRIM(fct_lower(cl_ tmp)) == TRIM(cp_extrap_list(jj)) )THEN7789 IF( TRIM(fct_lower(cl_ext)) == TRIM(cp_extrap_list(jj)) )THEN 7105 7790 var__get_extrap(1)=TRIM(cp_extrap_list(jj)) 7106 7791 … … 7111 7796 ENDIF 7112 7797 ENDDO 7113 IF( jj /= ip_nextrap + 1 ) EXIT 7114 ji=ji+1 7115 cl_tmp=fct_split(cd_varinfo,ji,';') 7116 ENDDO 7798 ENDIF 7117 7799 7118 7800 … … 7124 7806 !> 7125 7807 !> @details 7126 !> split namelist information, using ';' as separator. 7808 !> filter method is assume to follow string "flt =" 7809 !> 7127 7810 !> compare method name with the list of filter method available (see 7128 7811 !> module global). 7129 !> look for the number of turn, using '*' separator, and method parameters inside7812 !> look for the number of run, using '*' separator, and method parameters inside 7130 7813 !> bracket.<br/> 7131 7814 !> Example:<br/> 7132 !> - cubic ;2*hamming(2,3)7133 !> - hann7815 !> - int=cubic ; flt=2*hamming(2,3) 7816 !> - flt=hann 7134 7817 !> see @ref filter module for more information. 7135 7818 !> 7136 7819 !> @author J.Paul 7137 !> - November, 2013- Initial Version 7138 ! 7820 !> @date November, 2013 - Initial Version 7821 !> @date June, 2015 7822 !> - change way to get information in namelist, 7823 !> value follows string "flt =" 7824 !> 7139 7825 !> @param[in] cd_name variable name 7140 7826 !> @param[in] cd_varinfo variable information read in namelist … … 7151 7837 ! local variable 7152 7838 CHARACTER(LEN=lc) :: cl_tmp 7839 CHARACTER(LEN=lc) :: cl_flt 7153 7840 INTEGER(i4) :: il_ind 7154 7841 … … 7163 7850 cl_tmp=fct_split(cd_varinfo,ji,';') 7164 7851 DO WHILE( TRIM(cl_tmp) /= '' ) 7852 il_ind=INDEX(TRIM(cl_tmp),'flt') 7853 IF( il_ind /= 0 )THEN 7854 cl_flt=fct_split(cl_tmp,2,'=') 7855 EXIT 7856 ENDIF 7857 ji=ji+1 7858 cl_tmp=fct_split(cd_varinfo,ji,';') 7859 ENDDO 7860 7861 IF( TRIM(cl_flt) /= '' )THEN 7165 7862 DO jj=1,ip_nfilter 7166 il_ind=INDEX(fct_lower(cl_ tmp),TRIM(cp_filter_list(jj)))7863 il_ind=INDEX(fct_lower(cl_flt),TRIM(cp_filter_list(jj))) 7167 7864 IF( il_ind /= 0 )THEN 7168 7865 var__get_filter(1)=TRIM(cp_filter_list(jj)) 7169 7866 7170 ! look for number of turn7171 il_ind=SCAN(fct_lower(cl_ tmp),'*')7867 ! look for number of run 7868 il_ind=SCAN(fct_lower(cl_flt),'*') 7172 7869 IF( il_ind /=0 )THEN 7173 IF( fct_is_num(cl_ tmp(1:il_ind-1)) )THEN7174 var__get_filter(2)=TRIM(cl_ tmp(1:il_ind-1))7175 ELSE IF( fct_is_num(cl_ tmp(il_ind+1:)) )THEN7176 var__get_filter(2)=TRIM(cl_ tmp(il_ind+1:))7870 IF( fct_is_num(cl_flt(1:il_ind-1)) )THEN 7871 var__get_filter(2)=TRIM(cl_flt(1:il_ind-1)) 7872 ELSE IF( fct_is_num(cl_flt(il_ind+1:)) )THEN 7873 var__get_filter(2)=TRIM(cl_flt(il_ind+1:)) 7177 7874 ELSE 7178 7875 var__get_filter(2)='1' … … 7183 7880 7184 7881 ! look for filter parameter 7185 il_ind=SCAN(fct_lower(cl_ tmp),'(')7882 il_ind=SCAN(fct_lower(cl_flt),'(') 7186 7883 IF( il_ind /=0 )THEN 7187 cl_ tmp=TRIM(cl_tmp(il_ind+1:))7188 il_ind=SCAN(fct_lower(cl_ tmp),')')7884 cl_flt=TRIM(cl_flt(il_ind+1:)) 7885 il_ind=SCAN(fct_lower(cl_flt),')') 7189 7886 IF( il_ind /=0 )THEN 7190 cl_ tmp=TRIM(cl_tmp(1:il_ind-1))7887 cl_flt=TRIM(cl_flt(1:il_ind-1)) 7191 7888 ! look for cut-off frequency 7192 var__get_filter(3)=fct_split(cl_ tmp,1,',')7889 var__get_filter(3)=fct_split(cl_flt,1,',') 7193 7890 ! look for halo size 7194 var__get_filter(4)=fct_split(cl_ tmp,2,',')7891 var__get_filter(4)=fct_split(cl_flt,2,',') 7195 7892 ! look for alpha parameter 7196 var__get_filter(5)=fct_split(cl_ tmp,3,',')7893 var__get_filter(5)=fct_split(cl_flt,3,',') 7197 7894 ELSE 7198 7895 CALL logger_error("VAR GET FILTER: variable "//& … … 7215 7912 ENDIF 7216 7913 ENDDO 7217 IF( jj /= ip_nfilter + 1 ) EXIT 7914 ENDIF 7915 7916 END FUNCTION var__get_filter 7917 !------------------------------------------------------------------- 7918 !> @brief 7919 !> This function check if variable information read in namelist contains 7920 !> unit and return it if true. 7921 !> 7922 !> @details 7923 !> unit is assume to follow string "unt =" 7924 !> 7925 !> @author J.Paul 7926 !> @date June, 2015 - Initial Version 7927 ! 7928 !> @param[in] cd_name variable name 7929 !> @param[in] cd_varinfo variable information read in namelist 7930 !> @return unit string character 7931 !------------------------------------------------------------------- 7932 FUNCTION var__get_unt( cd_name, cd_varinfo ) 7933 IMPLICIT NONE 7934 ! Argument 7935 CHARACTER(LEN=*), INTENT(IN ) :: cd_name 7936 CHARACTER(LEN=*), INTENT(IN ) :: cd_varinfo 7937 7938 ! function 7939 CHARACTER(LEN=lc) :: var__get_unt 7940 7941 ! local variable 7942 CHARACTER(LEN=lc) :: cl_tmp 7943 7944 INTEGER(i4) :: il_ind 7945 7946 ! loop indices 7947 INTEGER(i4) :: ji 7948 !---------------------------------------------------------------- 7949 7950 var__get_unt='' 7951 7952 ji=1 7953 cl_tmp=fct_split(cd_varinfo,ji,';') 7954 DO WHILE( TRIM(cl_tmp) /= '' ) 7955 il_ind=INDEX(TRIM(cl_tmp),'unt') 7956 IF( il_ind /= 0 )THEN 7957 var__get_unt=fct_split(cl_tmp,2,'=') 7958 EXIT 7959 ENDIF 7218 7960 ji=ji+1 7219 7961 cl_tmp=fct_split(cd_varinfo,ji,';') 7220 7962 ENDDO 7221 7963 7222 END FUNCTION var__get_filter 7964 IF( TRIM(var__get_unt) /= '' )THEN 7965 CALL logger_debug("VAR GET UNIT: will use units "//& 7966 & TRIM(var__get_unt)//" for variable "//& 7967 & TRIM(cd_name) ) 7968 ENDIF 7969 7970 END FUNCTION var__get_unt 7223 7971 !------------------------------------------------------------------- 7224 7972 !> @brief … … 7227 7975 !> 7228 7976 !> @author J.Paul 7229 !> - November, 2013- Initial Version7977 !> @date November, 2013 - Initial Version 7230 7978 ! 7231 7979 !> @param[in] td_var array of variable structure … … 7285 8033 !> 7286 8034 !> @author J.Paul 7287 !> - November, 2013- Initial Version8035 !> @date November, 2013 - Initial Version 7288 8036 ! 7289 8037 !> @param[inout] td_var variable structure … … 7321 8069 !------------------------------------------------------------------- 7322 8070 !> @brief 8071 !> This subroutine replace unit name of the variable, 8072 !> and apply unit factor to the value of this variable. 8073 !> 8074 !> @details 8075 !> new unit name (unt) and unit factor (unf) are read from the namelist. 8076 !> 8077 !> @note the variable value should be already read. 8078 !> 8079 !> @author J.Paul 8080 !> @date June, 2015 - Initial Version 8081 ! 8082 !> @param[inout] td_var variable structure 8083 !------------------------------------------------------------------- 8084 SUBROUTINE var_chg_unit( td_var ) 8085 IMPLICIT NONE 8086 ! Argument 8087 TYPE(TVAR), INTENT(INOUT) :: td_var 8088 8089 ! local variable 8090 TYPE(TATT) :: tl_att 8091 8092 ! loop indices 8093 !---------------------------------------------------------------- 8094 8095 IF( ASSOCIATED(td_var%d_value) )THEN 8096 !- change value 8097 IF( td_var%d_unf /= 1._dp )THEN 8098 WHERE( td_var%d_value(:,:,:,:) /= td_var%d_fill ) 8099 td_var%d_value(:,:,:,:)=td_var%d_value(:,:,:,:)*td_var%d_unf 8100 END WHERE 8101 8102 !- change scale factor and offset to avoid mistake 8103 tl_att=att_init('scale_factor',1) 8104 CALL var_move_att(td_var, tl_att) 8105 8106 tl_att=att_init('add_offset',0) 8107 CALL var_move_att(td_var, tl_att) 8108 ENDIF 8109 8110 !- change unit name 8111 IF( TRIM(td_var%c_unt) /= TRIM(td_var%c_units) .AND. & 8112 & TRIM(td_var%c_unt) /= '' )THEN 8113 tl_att=att_init('units',TRIM(td_var%c_unt)) 8114 CALL var_move_att(td_var,tl_att) 8115 ENDIF 8116 8117 ENDIF 8118 8119 END SUBROUTINE var_chg_unit 8120 !------------------------------------------------------------------- 8121 !> @brief 7323 8122 !> This subroutine check variable dimension expected, as defined in 7324 8123 !> file 'variable.cfg'. … … 7329 8128 !> 7330 8129 !> @author J.Paul 7331 !> - November, 2013- Initial Version8130 !> @date November, 2013 - Initial Version 7332 8131 ! 7333 8132 !> @param[inout] td_var variable structure … … 7414 8213 !> 7415 8214 !> @author J.Paul 7416 !> - August, 2014- Initial Version 8215 !> @date August, 2014 - Initial Version 8216 !> @date July 2015 8217 !> - do not use dim_disorder anymore 7417 8218 ! 7418 8219 !> @param[inout] td_var variable structure … … 7438 8239 IF( PRESENT(cd_dimorder) ) cl_dimorder=TRIM(ADJUSTL(cd_dimorder)) 7439 8240 8241 CALL logger_debug("VAR REORDER: work on "//TRIM(td_var%c_name)//& 8242 & " new dimension order "//TRIM(cl_dimorder)) 8243 7440 8244 tl_dim(:)=dim_copy(td_var%t_dim(:)) 7441 8245 7442 CALL dim_unorder(tl_dim(:))7443 8246 CALL dim_reorder(tl_dim(:),TRIM(cl_dimorder)) 7444 8247 … … 7467 8270 !> 7468 8271 !> @author J.Paul 7469 !> - September, 2014- Initial Version8272 !> @date September, 2014 - Initial Version 7470 8273 ! 7471 8274 !> @param[in] td_var array of variable structure … … 7492 8295 !> 7493 8296 !> @author J.Paul 7494 !> - November, 2014- Initial Version8297 !> @date November, 2014 - Initial Version 7495 8298 ! 7496 8299 !> @param[in] td_var time variable structure
Note: See TracChangeset
for help on using the changeset viewer.